Como Criar um Agente de IA Local com Python: Análise Inteligente de Dados em Minutos

Você já imaginou poder analisar documentos e extrair informações relevantes sem depender de serviços de IA na nuvem? Hoje, vamos explorar como construir um agente de IA totalmente local usando Python, que pode processar dados, responder perguntas e fornecer insights valiosos – tudo isso rodando diretamente no seu computador e sem custo adicional.

Neste guia completo, vou mostrar como desenvolver uma aplicação capaz de analisar um arquivo CSV com reviews de restaurantes, usando técnicas de Retrieval Augmented Generation (RAG) para encontrar e processar informações relevantes. O melhor de tudo? Não precisamos de API keys da OpenAI ou outros serviços pagos!

Por que criar um agente de IA local?

Antes de mergulharmos no código, vamos entender os benefícios de ter um agente de IA rodando localmente:

• Privacidade total dos dados
• Sem custos mensais de APIs
• Funcionamento offline
• Controle completo sobre o processamento
• Velocidade superior em muitos casos

Em nosso exemplo, criaremos um assistente que analisa reviews de um restaurante de pizza, mas a mesma técnica pode ser aplicada a qualquer tipo de documento: relatórios, manuais técnicos, livros ou bases de conhecimento.

Ferramentas e bibliotecas necessárias

Para construir nosso agente local, utilizaremos:

• LangChain: framework para conectar componentes de IA
• Ollama: software para rodar modelos de IA localmente
• ChromaDB: banco de dados vetorial para armazenar e buscar informações
• Pandas: para manipulação de dados em CSV

Vamos iniciar configurando nosso ambiente de desenvolvimento e instalando as dependências necessárias.

Configurando o ambiente de desenvolvimento

Preparando o ambiente Python

Primeiro, vamos criar um ambiente virtual para isolar nossas dependências:

Para Windows: python -m venv env
Para Mac/Linux: python3 -m venv venv

Em seguida, ativamos o ambiente:

Para Windows: .\env\Scripts\activate
Para Mac/Linux: source venv/bin/activate

Agora, instalamos as bibliotecas necessárias:

pip install langchain langchain-ollama langchain-chroma pandas

Instalando o Ollama

O Ollama é o software que nos permitirá executar modelos de IA localmente. Para instalá-lo:

1. Visite ollama.com e baixe a versão apropriada para seu sistema
2. Instale o software seguindo as instruções na tela
3. Verifique a instalação abrindo um terminal e digitando ollama

Baixando os modelos necessários

Para nosso projeto, precisamos de dois modelos: um para geração de texto e outro para embeddings (vetorização de texto):

ollama pull llama3.2
ollama pull mxbai-embed-large

O primeiro modelo (llama3.2) será usado para gerar respostas, enquanto o segundo (mxbai-embed-large) converterá nossos textos em representações vetoriais para busca semântica.

Estruturando nosso projeto

Nosso projeto terá dois arquivos principais:

• main.py: conterá a lógica principal do nosso agente
• vector.py: responsável pela busca vetorial e manipulação dos documentos

Além disso, teremos um arquivo CSV contendo os dados que queremos analisar – no nosso caso, reviews de um restaurante de pizza.

Criando a busca vetorial com ChromaDB

Vamos começar implementando o arquivo vector.py, que será responsável por transformar nosso CSV em um banco de dados vetorial pesquisável:

Primeiro, importamos as bibliotecas necessárias:

from langchain_ollama import OllamaEmbeddings
from langchain_chroma import Chroma
from langchain_core.documents import Document
import os
import pandas as pd

Em seguida, carregamos o CSV e configuramos o modelo de embeddings:

df = pd.read_csv(“restaurant_reviews.csv”)
embeddings = OllamaEmbeddings(model=”mxbai-embed-large”)

Agora definimos o local onde armazenaremos nosso banco de dados vetorial:

db_location = “./chroma_langchain_db”
add_documents = not os.path.exists(db_location)

O próximo passo é converter os dados do CSV em documentos para o ChromaDB:

if add_documents:
    documents = []     ids = []     for i, row in df.iterrows():
        document = Document(
            page_content=row[“title”] + ” ” + row[“review”],
            metadata={“rating”: row[“rating”], “date”: row[“date”]}
        )
        ids.append(str(i))
        documents.append(document)

Finalmente, criamos nosso banco de dados vetorial e adicionamos os documentos (apenas se for a primeira execução):

vector_store = Chroma(
    collection_name=”restaurant_reviews”,
    persist_directory=db_location,
    embedding_function=embeddings
)

if add_documents:
    vector_store.add_documents(documents=documents, ids=ids)

Por fim, adicionamos uma função para encontrar documentos relevantes:

def get_relevant_documents(query, k=3):
    return vector_store.similarity_search(query, k=k)

Desenvolvendo o agente de IA principal

Agora, vamos implementar o arquivo main.py, que conterá a lógica principal do nosso agente:

Primeiro, importamos as dependências e nosso módulo de busca vetorial:

from langchain_ollama import Ollama
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
import vector

Em seguida, configuramos nosso modelo LLM local:

model = Ollama(model=”llama3.2″)

Criamos um template de prompt para o modelo seguir:

template = “””
You are an expert in answering questions about a pizza restaurant.
Here are some relevant reviews: {reviews}

Here is the question to answer: {question}

Based on ONLY the information in the reviews, answer the question.
If the information isn’t available in the reviews, say so clearly.
“””

Montamos a cadeia de processamento usando LangChain:

prompt = ChatPromptTemplate.from_template(template)
chain = prompt | model | StrOutputParser()

Finalmente, implementamos um loop para interação contínua com o usuário:

while True:
    question = input(“Ask your question (Q to quit): “)
    
    if question.lower() == ‘q’:
        break
    
    # Buscar documentos relevantes
    relevant_docs = vector.get_relevant_documents(question)
    reviews = [doc.page_content for doc in relevant_docs]     
    # Invocar o modelo
    result = chain.invoke({“reviews”: reviews, “question”: question})
    
    print(“\n” + “-“*80 + “\n”)
    print(result)
    print(“\n” + “-“*80 + “\n”)

Usando o agente na prática

Nosso agente de IA local está pronto! Para utilizá-lo, basta executar o arquivo main.py:

python main.py

Agora você pode fazer perguntas sobre o restaurante, como:

• “Como é a qualidade da pizza?”
• “Existem opções veganas?”
• “Qual é o prato mais elogiado nas avaliações?”
• “O que as pessoas dizem sobre o atendimento?”

O agente irá buscar os reviews mais relevantes para sua pergunta, analisá-los e fornecer uma resposta sintetizada com base apenas nos dados disponíveis.

Expandindo as capacidades do seu agente

Este é apenas o começo! Existem diversas maneiras de aprimorar seu agente de IA local:

• Processamento de PDFs: adapte o código para trabalhar com documentos PDF usando a biblioteca PyPDF2
• Interface gráfica: adicione uma interface usando Streamlit ou Gradio
• Modelos maiores: se seu hardware permitir, experimente modelos mais potentes como o Llama-3-70B
• Análise multimodal: integre capacidades de processamento de imagens

Com este conhecimento, você pode criar agentes especializados para diversas aplicações, desde análise de dados até assistentes de pesquisa acadêmica.

Potencialize seus projetos com IA local

Agora você possui as ferramentas para construir sistemas de IA sofisticados que rodam inteiramente no seu próprio hardware. Experimente adaptar este projeto para seus próprios casos de uso – analise documentos internos da empresa, crie um assistente para seus estudos ou desenvolva ferramentas personalizadas de análise de dados.

Não deixe de experimentar diferentes tipos de documentos e modelos para encontrar a combinação ideal para suas necessidades. A IA local traz independência, privacidade e economia – aproveite ao máximo!

Gostou deste tutorial? Compartilhe sua experiência e os projetos que você criar utilizando estas técnicas. O mundo da IA local está apenas começando, e as possibilidades são infinitas!

Perguntas Frequentes