DEV Community

Cover image for Como Construir um Chat AI usando Python e Groq Cloud
Zoranildo Santos
Zoranildo Santos

Posted on • Edited on

Como Construir um Chat AI usando Python e Groq Cloud

#python #chatbot #groq #ia

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
Enter fullscreen mode Exit fullscreen mode

Configuração Inicial

  1. 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
Enter fullscreen mode Exit fullscreen mode
  1. Instale as dependências necessárias: 
pip install fastapi uvicorn langchain-groq python-dotenv pydantic
Enter fullscreen mode Exit fullscreen mode
  1. 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
Enter fullscreen mode Exit fullscreen mode
  1. Crie um arquivo .env na raiz do projeto: 
GROQ_API_KEY=sua_api_key_aqui
Enter fullscreen mode Exit fullscreen mode

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}") ])
Enter fullscreen mode Exit fullscreen mode

2. Definindo a Entidade Message

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

from pydantic import BaseModel class Message(BaseModel): content: str
Enter fullscreen mode Exit fullscreen mode

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)}")
Enter fullscreen mode Exit fullscreen mode

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))
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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)
Enter fullscreen mode Exit fullscreen mode

Como Usar

  1. Configure suas variáveis de ambiente: 
export GROQ_API_KEY=sua_api_key_aqui
Enter fullscreen mode Exit fullscreen mode
  1. Execute o servidor: 
uvicorn main:app --reload
Enter fullscreen mode Exit fullscreen mode
  1. Acesse a documentação da API: 
http://localhost:8000/docs
Enter fullscreen mode Exit fullscreen mode
  1. 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?"}'
Enter fullscreen mode Exit fullscreen mode

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:

  1. Adicionar interface frontend (React, Vue.js, etc.)
  2. Implementar histórico de conversas com banco de dados
  3. Adicionar suporte a diferentes modelos
  4. Implementar cache de respostas com Redis
  5. Adicionar testes automatizados com pytest
  6. Implementar autenticação e autorização
  7. Adicionar rate limiting e middleware de segurança
  8. Implementar diferentes tipos de memória do LangChain (ConversationSummaryMemory, ConversationBufferWindowMemory)
  9. Adicionar suporte a diferentes tipos de prompts e templates
  10. 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.

Recursos Úteis

Top comments (0)