Como Construir um Chat AI usando Python e Groq Cloud

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/
│   │   └── aichat/
│   │       ├── entities/
│   │       │   └── message.py
│   │       └── usecases/
│   │           └── processmessageusecase.py
│   └── interfaces/
│       ├── controllers/
│       │   └── aichatcontroller.py
│       └── routes/
│           └── aichatroutes.py
├── config/
│   └── langchaingroq_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:

fastapi0.109.2
uvicorn0.27.1
pydantic>=2.7.4,<3.0.0
groq0.4.2
python-dotenv1.0.1
langchain0.3.19
langchain-groq0.2.4

Crie um arquivo .env na raiz do projeto:

GROQAPIKEY=suaapikey_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 loaddotenv
from langchaingroq import ChatGroq
from langchain.memory import ConversationBufferMemory
from langchain.prompts import ChatPromptTemplate

loaddotenv()

DEFAULTMODEL = "mixtral-8x7b-32768"
DEFAULTROLE = "user"

def creategroqclient() -> ChatGroq:
    apikey = os.getenv("GROQAPIKEY")
    if not apikey:
        raise ValueError("GROQAPIKEY não encontrada nas variáveis de ambiente")

    # Criando o cliente Groq com configurações otimizadas
    return ChatGroq(
        groqapikey=apikey,
        modelname=DEFAULTMODEL,
        temperature=0.7,
        maxtokens=1000
    )

def creatememory() -> ConversationBufferMemory:
    return ConversationBufferMemory(
        memorykey="chathistory",
        returnmessages=True
    )

def createprompttemplate() -> ChatPromptTemplate:
    return ChatPromptTemplate.frommessages([
        ("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 langchaingroq import ChatGroq
from langchain.prompts import ChatPromptTemplate
from langchain.memory import ConversationBufferMemory
from src.domain.aichat.entities.message import Message
from config.langchaingroqconfig import creategroqclient, creatememory, createprompttemplate


class ProcessMessageUseCase:
    def _init_(self, groqclient: Optional[ChatGroq] = None):
        self.groqclient = groqclient or creategroqclient()
        self.memory = creatememory()
        self.prompttemplate = createprompttemplate()

    async def execute(self, message: Message) -> str:
        try:
            # Criando a chain com memória e prompt template
            chain = self.prompttemplate | self.groqclient

            # Executando a chain com o histórico de conversa
            response = await chain.ainvoke({
                "input": message.content,
                "chathistory": self.memory.chatmemory.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.aichat.entities.message import Message
from src.domain.aichat.usecases.processmessageusecase import ProcessMessageUseCase

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

    def setuproutes(self):
        self.router.addapiroute(
            "/chat",
            self.chat,
            methods=["POST"],
            responsemodel=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.processmessageusecase.execute(message)
            return {"response": response}
        except ValueError as e:
            raise HTTPException(statuscode=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.aichatcontroller import AIChatController

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

    router.includerouter(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.aichatroutes import setuproutes

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

try:
    app.includerouter(setuproutes())
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 GROQAPI_KEY está configurada corretamente", file=sys.stderr)
    sys.exit(1)

Como Usar

Configure suas variáveis de ambiente:
```
export GROQAPIKEY=suaapikey_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.