✨ feat: Adicionando os endpoints de acesso as Tools e movendo o acesso para o banco de dados.

app/api/schemas.py

@@ -1,4 +1,5 @@
 from pydantic import BaseModel
+from typing import Dict, Any
 
 class ChatRequest(BaseModel):
     message: str
@@ -6,3 +7,20 @@ class ChatRequest(BaseModel):
 
 class ChatResponse(BaseModel):
     response: str
+
+
+
+class ToolCreate(BaseModel):
+    name: str
+    description: str
+    parameters: Dict[str, Any]
+
+
+class ToolResponse(BaseModel):
+    id: int
+    name: str
+    description: str
+    parameters: Dict[str, Any]
+
+    class Config:
+        from_attributes = True

app/api/tool_routes.py

@@ -0,0 +1,54 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from app.db.database import SessionLocal
+from app.repositories.tool_repository import ToolRepository
+from app.api.schemas import ToolCreate, ToolResponse
+
+router = APIRouter(prefix="/tools", tags=["Tools"])
+
+
+# Dependency para abrir e fechar conexão automaticamente
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+
+@router.post("/", response_model=ToolResponse)
+def create_tool(tool: ToolCreate, db: Session = Depends(get_db)):
+    repo = ToolRepository(db)
+    return repo.create(
+        name=tool.name,
+        description=tool.description,
+        parameters=tool.parameters
+    )
+
+
+@router.get("/", response_model=list[ToolResponse])
+def list_tools(db: Session = Depends(get_db)):
+    repo = ToolRepository(db)
+    return repo.get_all()
+
+
+@router.get("/{tool_id}", response_model=ToolResponse)
+def get_tool(tool_id: int, db: Session = Depends(get_db)):
+    repo = ToolRepository(db)
+    tool = repo.get_by_id(tool_id)
+
+    if not tool:
+        raise HTTPException(status_code=404, detail="Tool não encontrada")
+
+    return tool
+
+
+@router.delete("/{tool_id}")
+def delete_tool(tool_id: int, db: Session = Depends(get_db)):
+    repo = ToolRepository(db)
+    tool = repo.delete(tool_id)
+
+    if not tool:
+        raise HTTPException(status_code=404, detail="Tool não encontrada")
+
+    return {"message": "Tool removida com sucesso"}

app/core/settings.py

@@ -5,6 +5,14 @@ class Settings(BaseSettings):
     google_project_id: str
     google_location: str = "us-central1"
 
+    # Database -> Retirar antes de subir para a nuvem
+    db_host: str
+    db_port: int = 3306
+    db_user: str
+    db_password: str
+    db_name: str
+
+
     class Config:
         env_file = ".env"
 

app/db/database.py

@@ -0,0 +1,21 @@
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker, declarative_base
+from app.core.settings import settings
+
+DATABASE_URL = (
+    f"mysql+pymysql://{settings.db_user}:"
+    f"{settings.db_password}@"
+    f"{settings.db_host}:"
+    f"{settings.db_port}/"
+    f"{settings.db_name}"
+)
+
+engine = create_engine(DATABASE_URL, echo=True)
+
+SessionLocal = sessionmaker(
+    autocommit=False,
+    autoflush=False,
+    bind=engine
+)
+
+Base = declarative_base()

app/db/models.py

@@ -0,0 +1,26 @@
+from sqlalchemy import Column, Integer, String, Text, JSON, TIMESTAMP
+from sqlalchemy.sql import func
+from app.db.database import Base
+
+
+class Tool(Base):
+    __tablename__ = "tools"
+
+    id = Column(Integer, primary_key=True, index=True)
+
+    name = Column(String(100), unique=True, nullable=False)
+
+    description = Column(Text, nullable=False)
+
+    parameters = Column(JSON, nullable=False)
+
+    created_at = Column(
+        TIMESTAMP,
+        server_default=func.current_timestamp()
+    )
+
+    updated_at = Column(
+        TIMESTAMP,
+        server_default=func.current_timestamp(),
+        onupdate=func.current_timestamp()
+    )

app/main.py

@@ -1,6 +1,8 @@
 from fastapi import FastAPI
 from app.api.routes import router
+from app.api.tool_routes import router as tool_router
 
 app = FastAPI(title="AI Orquestrador")
 
 app.include_router(router)
+app.include_router(tool_router)

app/repositories/tool_repository.py

@@ -0,0 +1,32 @@
+from sqlalchemy.orm import Session
+from app.db.models import Tool
+
+
+class ToolRepository:
+
+    def __init__(self, db: Session):
+        self.db = db
+
+    def get_all(self):
+        return self.db.query(Tool).all()
+
+    def get_by_id(self, tool_id: int):
+        return self.db.query(Tool).filter(Tool.id == tool_id).first()
+
+    def create(self, name: str, description: str, parameters: dict):
+        tool = Tool(
+            name=name,
+            description=description,
+            parameters=parameters
+        )
+        self.db.add(tool)
+        self.db.commit()
+        self.db.refresh(tool)
+        return tool
+
+    def delete(self, tool_id: int):
+        tool = self.get_by_id(tool_id)
+        if tool:
+            self.db.delete(tool)
+            self.db.commit()
+        return tool

app/services/tool_registry.py

@@ -1,13 +1,13 @@
 from typing import List
 from app.models.tool_model import ToolDefinition
-from app.integrations.estoque_service import consultar_estoque
+# from app.integrations.estoque_service import consultar_estoque
 
 
 class ToolRegistry:
 
     def __init__(self):
         self._tools = []
-
+        """
         # Registrando manualmente por enquanto, porém isso poderia vir de um BD.
         self.register_tool(
             name="consultar_estoque",
@@ -24,7 +24,7 @@ class ToolRegistry:
             },
             handler=consultar_estoque
         )
-
+    """
 
     # O método abaixo serve para adicionar uma nova tool ao sistema (podendo inserir a lógica de adcicionar ao BD futuramente).
     def register_tool(self, name, description, parameters, handler):