Como Construir um Chat AI usando Python e Groq Cloud

Neste artigo, vou mostrar como construir um assistente virtual utilizando Python e a API da Groq Cloud. Vamos criar uma aplicação que permite interagir com modelos de linguagem avançados de forma simples e eficiente. O que é Groq? Groq é uma empresa que oferece acesso a modelos de linguagem de última geração através de sua API. Uma das principais vantagens da Groq é sua velocidade de inferência, oferecendo respostas mais rápidas em comparação com outras soluções disponíveis no mercado. Pré-requisitos Python 3.8+ Conhecimento básico de Python Uma conta na Groq (para obter a API key) FastAPI Uvicorn (servidor ASGI) Estrutura do Projeto ├── 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 Configuração Inicial Primeiro, crie um novo projeto e instale as dependências necessárias: mkdir chat cd chat python -m venv venv source venv/bin/activate # No Windows use: .\venv\Scripts\activate Instale as dependências necessárias: pip install fastapi uvicorn langchain-groq python-dotenv pydantic Crie um arquivo requirements.txt: fastapi==0.109.2 uvicorn==0.27.1 pydantic>=2.7.4, 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 ) 2. Definindo a Entidade Message Crie o arquivo src/domain/ai_chat/entities/message.py: from pydantic import BaseModel class Message(BaseModel): content: str 3. Implementando o Use Case Crie o arquivo src/domain/ai_chat/use_cases/process_message_use_case.py: 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)}") 4. Criando o Controller Crie o arquivo src/interfaces/controllers/ai_chat_controller.py: 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)) 5. Configurando as Rotas Crie o arquivo src/interfaces/routes/ai_chat_routes.py: 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 6. Implementando o Arquivo Principal Agora, vamos criar o arquivo principal da aplicação main.py: 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",

Mar 2, 2025 - 02:16

Como Construir um Chat AI usando Python e Groq Cloud

Neste artigo, vou mostrar como construir um assistente virtual utilizando Python e a API da Groq Cloud. Vamos criar uma aplicação que permite interagir com modelos de linguagem avançados de forma simples e eficiente.

O que é Groq?

Groq é uma empresa que oferece acesso a modelos de linguagem de última geração através de sua API. Uma das principais vantagens da Groq é sua velocidade de inferência, oferecendo respostas mais rápidas em comparação com outras soluções disponíveis no mercado.

Pré-requisitos

Python 3.8+
Conhecimento básico de Python
Uma conta na Groq (para obter a API key)
FastAPI
Uvicorn (servidor ASGI)

Estrutura do Projeto

├── 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

Configuração Inicial

Primeiro, crie um novo projeto e instale as dependências necessárias:

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

Instale as dependências necessárias:

pip install fastapi uvicorn langchain-groq python-dotenv pydantic

Crie um arquivo requirements.txt:

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

Crie um arquivo .env na raiz do projeto:

GROQ_API_KEY=sua_api_key_aqui

Implementação

1. Configuração do Cliente Groq

Primeiro, vamos configurar o cliente da Groq. Crie o arquivo config/langchain_groq_config.py:

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
    )

2. Definindo a Entidade Message

Crie o arquivo src/domain/ai_chat/entities/message.py:

from pydantic import BaseModel

class Message(BaseModel):
    content: str

3. Implementando o Use Case

Crie o arquivo src/domain/ai_chat/use_cases/process_message_use_case.py:

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)}")

4. Criando o Controller

Crie o arquivo src/interfaces/controllers/ai_chat_controller.py:

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))

5. Configurando as Rotas

Crie o arquivo src/interfaces/routes/ai_chat_routes.py:

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

6. Implementando o Arquivo Principal

Agora, vamos criar o arquivo principal da aplicação main.py:

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)

Como Usar

Configure suas variáveis de ambiente:

export GROQ_API_KEY=sua_api_key_aqui

Execute o servidor:

uvicorn main:app --reload

Acesse a documentação da API:

http://localhost:8000/docs

Faça uma requisição para o chat:

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

Considerações de Segurança

Nunca compartilhe sua API key
Utilize variáveis de ambiente para armazenar informações sensíveis
Implemente rate limiting para controlar o uso da API

Próximos Passos

Algumas sugestões para expandir o projeto:

Adicionar interface frontend (React, Vue.js, etc.)
Implementar histórico de conversas com banco de dados
Adicionar suporte a diferentes modelos
Implementar cache de respostas com Redis
Adicionar testes automatizados com pytest
Implementar autenticação e autorização
Adicionar rate limiting e middleware de segurança

Conclusão

Neste artigo, aprendemos como construir um chat utilizando Python e a API da Groq. A implementação segue boas práticas de desenvolvimento e pode ser facilmente expandida para incluir mais funcionalidades.