🔧 Como Construir um Chat AI usando Python e Groq Cloud
Nachrichtenbereich: 🔧 Programmierung
🔗 Quelle: dev.to
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
.envna 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.
Recursos Úteis
...
🔧 Como Instalar o Node.js LTS Usando o NVM
📈 26.6 Punkte
🔧 Programmierung
🔧 Como Instalar o Node.js LTS Usando o NVM
📈 26.6 Punkte
🔧 Programmierung