Como Construir Agentes de IA com SmolAgents e Deepseek R1

Introdução

A integração de modelos avançados de raciocínio e frameworks leves está transformando a forma como os sistemas de IA recuperam, processam e apresentam informações. Neste guia, construiremos um sistema de Geração Aumentada por Recuperação (RAG) usando DeepSeek R1, um modelo de raciocínio de alto desempenho, e SmolAgents, um framework de agente minimalista da Hugging Face. Este sistema permitirá processamento eficiente de documentos, busca inteligente e raciocínio parecido com o humano—ideal para aplicações de pesquisa, suporte ao cliente e gestão do conhecimento.

Requisitos do Sistema para Executar a Configuração

O agente de IA realizará quatro tarefas principais:

1. Carregar e Processar PDFs: Converter documentos em partes de texto pesquisáveis.
2. Criar um Banco de Dados Vetorial: Armazenar embeddings para pesquisa semântica rápida.
3. Recuperar e Raciocinar: Usar DeepSeek R1 para analisar dados recuperados e gerar respostas.
4. Interagir com Usuários: Fornecer uma interface conversacional para interação contínua.

Passo 1: Carregando e Processando Documentos PDF

Ferramentas e Bibliotecas

• LangChain: Para carregamento de documentos e divisão de texto.
• ChromaDB: Um banco de dados vetorial leve para armazenar embeddings.
• Embeddings da Hugging Face: Para converter texto em representações vetoriais.

Implementação

1.1 Carregar Arquivos PDF

Use o DirectoryLoader do LangChain para carregar todos os PDFs de um diretório. Cada PDF é dividido em páginas para processamento.

from langchain_community.document_loaders import DirectoryLoader, PyPDFLoader  
from langchain.text_splitter import RecursiveCharacterTextSplitter  

def load_and_process_pdfs(data_dir: str):  
    loader = DirectoryLoader(  
        data_dir,  
        glob="**/*.pdf",  
        loader_cls=PyPDFLoader  
    )  
    documents = loader.load()  

    # Dividir documentos em partes  
    text_splitter = RecursiveCharacterTextSplitter(  
        chunk_size=1000,  
        chunk_overlap=200,  
        length_function=len,  
    )  
    return text_splitter.split_documents(documents)  

1.2 Criar um Armazenamento Vetorial

Converter partes de texto em embeddings e armazená-las no ChromaDB para recuperação eficiente.

from langchain_huggingface import HuggingFaceEmbeddings  
from langchain_community.vectorstores import Chroma  
import os  
import shutil  

def create_vector_store(chunks, persist_directory: str):  
    if os.path.exists(persist_directory):  
        shutil.rmtree(persist_directory)  

    embeddings = HuggingFaceEmbeddings(  
        model_name="sentence-transformers/all-mpnet-base-v2",  
        model_kwargs={'device': 'cpu'}  
    )  

    vectordb = Chroma.from_documents(  
        documents=chunks,  
        embedding=embeddings,  
        persist_directory=persist_directory  
    )  
    return vectordb  

Considerações Chave

• Tamanho do Chunk: 1000 caracteres com 200 caracteres de sobreposição equilibram a retenção de contexto e a eficiência da busca.
• Modelo de Embedding: all-mpnet-base-v2 fornece embeddings de alta qualidade para frases.

Passo 2: Implementando o Agente de Raciocínio com DeepSeek R1

Por que DeepSeek R1?

DeepSeek R1 se especializa em raciocínio em múltiplas etapas, permitindo decompor consultas complexas, inferir relações e gerar respostas estruturadas.

Inicializar o Modelo de Raciocínio

Configure o DeepSeek R1 via Ollama para inferência local:

from smolagents import OpenAIServerModel, CodeAgent  

reasoning_model_id = "deepseek-r1:7b"  

def get_model(model_id):  
    return OpenAIServerModel(  
        model_id=model_id,  
        api_base="http://localhost:11434/v1",  
        api_key="ollama"  
    )  

reasoning_model = get_model(reasoning_model_id)  
reasoner = CodeAgent(  
    tools=[],  
    model=reasoning_model,  
    add_base_tools=False,  
    max_steps=2  # Limitar iterações de raciocínio para eficiência  
)  

Passo 3: Construindo o Pipeline de Geração Aumentada por Recuperação (RAG)

Design da Ferramenta

Criar uma ferramenta RAG que combine recuperação de documentos com as capacidades de raciocínio do DeepSeek R1.

from smolagents import tool  

@tool  
def rag_with_reasoner(user_query: str) -> str:  
    # Recuperar documentos relevantes  
    docs = vectordb.similarity_search(user_query, k=3)  
    context = "\n\n".join(doc.page_content for doc in docs)  

    # Gerar um prompt de raciocínio  
    prompt = f"""  
    Com base no seguinte contexto, responda à pergunta do usuário de forma concisa.  
    Se as informações forem insuficientes, sugira uma consulta refinada.  

    Contexto:  
    {context}  

    Pergunta: {user_query}  

    Resposta:  
    """  

    return reasoner.run(prompt, reset=False)  

Recursos Chave

• Prompts Contextuais: Injete documentos recuperados no prompt para respostas fundamentadas.
• Mecanismo de Retorno: O modelo sugere consultas melhores quando os dados são insuficientes.

Passo 4: Implantando o Agente Principal de IA

Orquestrando o Fluxo de Trabalho

O agente principal, alimentado pelo Llama 3.2, gerencia as interações do usuário e invoca a ferramenta RAG conforme necessário:

from smolagents import ToolCallingAgent, GradioUI  

tool_model = get_model("llama3.2")  
primary_agent = ToolCallingAgent(  
    tools=[rag_with_reasoner],  
    model=tool_model,  
    add_base_tools=False,  
    max_steps=3  
)  

def main():  
    GradioUI(primary_agent).launch()  

if __name__ == "__main__":  
    main()  

Interface do Usuário

A IU fornece uma interface web simples para interação em tempo real:

• Os usuários inserem consultas.
• O agente recupera documentos, raciocina com DeepSeek R1 e retorna respostas.

A integração do DeepSeek R1 e do SmolAgents oferece uma solução poderosa de IA que combina raciocínio aprimorado para dissecação de consultas complexas, recuperação eficiente por meio da pesquisa semântica rápida do ChromaDB, e implantação local econômica para evitar dependência de APIs de nuvem onerosas. Sua arquitetura escalável permite a integração contínua de novas ferramentas, tornando-a ideal para aplicações como pesquisa (análise de documentos técnicos), suporte ao cliente (resolução de FAQs) e gestão do conhecimento (transformação de recursos estáticos em sistemas interativos).

Futuras melhorias poderiam expandir o suporte a documentos para incluir Word, HTML e markdown, integrar busca em tempo real na web para contexto mais amplo, e implementar ciclos de feedback para aprimorar a precisão das respostas ao longo do tempo. Esta estrutura oferece uma base versátil para a construção de assistentes de IA inteligentes e adaptáveis, personalizados para diversas necessidades.