Neste artigo, vou mostrar como construir um assistente virtual utilizando Python, LangChain 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.
O que é LangChain?
O LangChain é um framework poderoso que facilita o desenvolvimento de aplicações baseadas em modelos de linguagem (LLMs). Ele oferece várias funcionalidades importantes:
- Gerenciamento de memória e contexto
- Criação de cadeias de processamento (chains)
- Integração com diferentes modelos de IA
- Manipulação de documentos e dados
- Criação de agentes autônomos
No nosso projeto, o LangChain será fundamental para:
- Gerenciar o contexto das conversas
- Criar prompts estruturados
- Integrar o modelo da Groq de forma eficiente
- Manter o histórico de interações
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 com LangChain
Primeiro, vamos configurar o cliente da Groq usando o LangChain. Crie o arquivo config/langchain_groq_config.py:
import os
from dotenv import load_dotenv
from langchain_groq import ChatGroq
from langchain.memory import ConversationBufferMemory
from langchain.prompts import ChatPromptTemplate
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")
# Criando o cliente Groq com configurações otimizadas
return ChatGroq(
groq_api_key=api_key,
model_name=DEFAULT_MODEL,
temperature=0.7,
max_tokens=1000
)
def create_memory() -> ConversationBufferMemory:
return ConversationBufferMemory(
memory_key="chat_history",
return_messages=True
)
def create_prompt_template() -> ChatPromptTemplate:
return ChatPromptTemplate.from_messages([
("system", "Você é um assistente pessoal chamado ZAgent, especializado em ajudar com tarefas domésticas."),
("human", "{input}"),
("assistant", "Vou ajudar você com isso. {chat_history}")
])
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 langchain.memory import ConversationBufferMemory
from src.domain.ai_chat.entities.message import Message
from config.langchain_groq_config import create_groq_client, create_memory, create_prompt_template
class ProcessMessageUseCase:
def __init__(self, groq_client: Optional[ChatGroq] = None):
self.groq_client = groq_client or create_groq_client()
self.memory = create_memory()
self.prompt_template = create_prompt_template()
async def execute(self, message: Message) -> str:
try:
# Criando a chain com memória e prompt template
chain = self.prompt_template | self.groq_client
# Executando a chain com o histórico de conversa
response = await chain.ainvoke({
"input": message.content,
"chat_history": self.memory.chat_memory.messages
})
# Salvando a interação na memória
self.memory.save_context(
{"input": message.content},
{"output": response.content}
)
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
- Considere implementar um sistema de cache para respostas frequentes
- Monitore o uso de tokens para controlar custos
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
- Implementar diferentes tipos de memória do LangChain (ConversationSummaryMemory, ConversationBufferWindowMemory)
- Adicionar suporte a diferentes tipos de prompts e templates
- Implementar agentes autônomos para tarefas específicas
Conclusão
Neste artigo, aprendemos como construir um chat utilizando Python, LangChain e a API da Groq. A implementação segue boas práticas de desenvolvimento e aproveita os recursos poderosos do LangChain para criar uma experiência mais inteligente e contextualizada.
Top comments (0)