Como Construir um Chat AI usando Python e Groq Cloud

├── src/
│   ├── domain/
│   │   └── ai_chat/
│   │       ├── entities/
│   │       │   └── message.py
│   │       └── use_cases/
│   │           └── process_message_use_case.py
│   └── interfaces/
│       ├── controllers/
│       │   └── ai_chat_controller.py
│       └── routes/
│           └── ai_chat_routes.py
├── config/
│   └── langchain_groq_config.py
└── requirements.txt

mkdir chat
cd chat
python -m venv venv
source venv/bin/activate  # No Windows use: .\venv\Scripts\activate

pip install fastapi uvicorn langchain-groq python-dotenv pydantic

fastapi==0.109.2
uvicorn==0.27.1
pydantic>=2.7.4,<3.0.0
groq==0.4.2
python-dotenv==1.0.1
langchain==0.3.19
langchain-groq==0.2.4

GROQ_API_KEY=sua_api_key_aqui

import os
from dotenv import load_dotenv
from langchain_groq import ChatGroq

load_dotenv()

DEFAULT_MODEL = "mixtral-8x7b-32768"
DEFAULT_ROLE = "user"

def create_groq_client() -> ChatGroq:
    api_key = os.getenv("GROQ_API_KEY")
    if not api_key:
        raise ValueError("GROQ_API_KEY não encontrada nas variáveis de ambiente")
    return ChatGroq(
        groq_api_key=api_key,
        model_name=DEFAULT_MODEL
    )

from pydantic import BaseModel

class Message(BaseModel):
    content: str

from typing import Optional
from langchain_groq import ChatGroq
from langchain.prompts import ChatPromptTemplate
from src.domain.ai_chat.entities.message import Message
from config.langchain_groq_config import create_groq_client


class ProcessMessageUseCase:
    def __init__(self, groq_client: Optional[ChatGroq] = None):
        self.groq_client = groq_client or create_groq_client()

    async def execute(self, message: Message) -> str:
        try:
            messages = [
                ("system", "Você é um assitente pessoal chamado ZAgent"),
                ("human", message.content)
            ]

            template = ChatPromptTemplate.from_messages(messages)
            chain = template | self.groq_client

            response = await chain.ainvoke({})

            return str(response.content)

        except Exception as e:
            raise Exception(f"Erro ao processar mensagem: {str(e)}")

from fastapi import APIRouter, HTTPException
from src.domain.ai_chat.entities.message import Message
from src.domain.ai_chat.use_cases.process_message_use_case import ProcessMessageUseCase

class AIChatController:
    def __init__(self):
        try:
            self.process_message_use_case = ProcessMessageUseCase()
            self.router = APIRouter()
            self._setup_routes()
        except ValueError as e:
            raise ValueError(f"Erro na configuração do controlador: {str(e)}")

    def _setup_routes(self):
        self.router.add_api_route(
            "/chat",
            self.chat,
            methods=["POST"],
            response_model=dict,
            summary="Processa uma mensagem usando IA",
            description="Recebe uma mensagem e retorna a resposta gerada pelo modelo de IA"
        )

    async def chat(self, message: Message) -> dict:
        try:
            response = await self.process_message_use_case.execute(message)
            return {"response": response}
        except ValueError as e:
            raise HTTPException(status_code=400, detail=str(e))
        except Exception as e:
            raise HTTPException(status_code=500, detail=str(e))

from fastapi import APIRouter
from src.interfaces.controllers.ai_chat_controller import AIChatController

def setup_routes() -> APIRouter:
    controller = AIChatController()
    router = APIRouter(prefix="/api/v1", tags=["AI Chat"])

    router.include_router(controller.router)
    return router

import sys
from fastapi import FastAPI
from src.interfaces.routes.ai_chat_routes import setup_routes

app = FastAPI(
    title="Minha API FastAPI",
    description="Uma API de exemplo usando FastAPI com chat IA",
    version="1.0.0"
)

try:
    app.include_router(setup_routes())
except ValueError as e:
    print(f"Erro fatal na inicialização da aplicação: {str(e)}", file=sys.stderr)
    print("Certifique-se de que a variável de ambiente GROQ_API_KEY está configurada corretamente", file=sys.stderr)
    sys.exit(1)

export GROQ_API_KEY=sua_api_key_aqui

uvicorn main:app --reload

http://localhost:8000/docs

curl -X POST "http://localhost:8000/api/v1/chat" \
     -H "Content-Type: application/json" \
     -d '{"content": "Olá, tudo bem?"}'