Construindo Agentes de IA com LangChain e Langgraph

Na era da inteligência artificial, o desenvolvimento de agentes que compreendem e interagem com informações de forma inteligente é essencial. O framework LangChain se destaca como uma ferramenta poderosa para a construção desses agentes. Este post explorará os principais conceitos e como LangChain possibilita a criação de agentes de IA eficientes.

O que é LangChain?

LangChain é uma biblioteca que permite integrar modelos de linguagem a fluxos de trabalho de IA mais amplos, fornecendo estruturas que simplificam o uso de modelos de aprendizado profundo para resolver problemas complexos. Ele oferece componentes fundamentais para que desenvolvedores e cientistas de dados possam construir agentes de IA baseados em LLMs (Large Language Models) de forma mais eficiente e escalável.

Principais Conceitos do LangChain

1. Modelos de Linguagem (LLMs)
   O núcleo do LangChain está nos modelos de linguagem de grande porte. Esses modelos são responsáveis por processar e gerar respostas em linguagem natural, tornando-se a base para diversos tipos de interações automatizadas. Modelos como GPT, BERT e outros fazem parte da arquitetura do LangChain, que permite integrar esses LLMs com outras funcionalidades.
2. Cadeias (Chains)
   Um dos principais conceitos do LangChain é o de Chains, que basicamente combinam modelos de linguagem com outros componentes para formar um fluxo de trabalho completo. Essas cadeias podem ser simples, como uma sequência de perguntas e respostas, ou complexas, envolvendo múltiplos modelos, dados externos e ações automatizadas.
3. Memória
   Um dos grandes desafios ao usar LLMs em fluxos de trabalho contínuos é o gerenciamento de estado. LangChain resolve isso com o conceito de Memória. Um agente de IA precisa reter informações de interações passadas para responder de maneira mais contextualizada, e a memória ajuda nesse processo. Isso é crucial para a construção de agentes que simulem conversas humanas longas e contextuais.
4. Agentes
   No contexto do LangChain, Agentes são programas que tomam decisões com base nas saídas de um LLM. Eles combinam diferentes componentes, como APIs, bancos de dados e ferramentas de execução de tarefas. Com isso, os agentes podem realizar ações automatizadas e baseadas em decisões, como fazer reservas de hotéis ou realizar buscas complexas em documentos.
5. Ferramentas
   LangChain permite que agentes utilizem diversas ferramentas para obter informações ou realizar ações. Por exemplo, um agente pode se conectar a uma API de pesquisa na web para buscar dados em tempo real. As ferramentas integram APIs e outras fontes de dados para expandir as capacidades dos agentes de IA.
6. Padrões e Integrações
   O LangChain foi projetado para ser flexível e modular. Ele suporta uma ampla variedade de integrações com APIs externas, bancos de dados, e frameworks de aprendizado de máquina. Essa modularidade permite que os desenvolvedores escolham e personalizem as ferramentas e métodos que melhor atendem às suas necessidades.

Benefícios do LangChain

• Escalabilidade: A arquitetura modular permite que as soluções cresçam com facilidade, adaptando-se a fluxos de trabalho maiores ou mais complexos.
• Eficiência: Com a integração de diferentes modelos e fontes de dados, LangChain automatiza muitos processos que, de outra forma, seriam feitos manualmente.
• Facilidade de Uso: A interface amigável e bem documentada facilita a implementação de agentes de IA, até mesmo para desenvolvedores com menos experiência em IA.

Casos de Uso

LangChain tem sido utilizado em diversos setores, como:

• Automação de Atendimento ao Cliente: Agentes capazes de responder perguntas frequentes, processar solicitações de suporte e interagir com clientes de forma humanizada.
• Análise de Documentos Jurídicos: Agentes especializados em extrair informações relevantes de contratos, legislações e outras fontes jurídicas.
• Pesquisa e Desenvolvimento: Modelos que auxiliam pesquisadores a acessar grandes volumes de informações técnicas e científicas, sintetizando dados relevantes.

Criando um Agente de IA com LangGraph em Python

Passo 1: Instalar Pacotes Necessários

!pip install -U langgraph langsmith langchain_anthropic tavily-python langchain_community

Passo 2: Definir o Estado do Gráfico O estado armazena as mensagens entre o usuário e o agente.

from typing import Annotated
from typing_extensions import TypedDict
from langgraph.graph import StateGraph, START, END
from langgraph.graph.message import add_messages

class State(TypedDict):
    messages: Annotated[list, add_messages]

graph_builder = StateGraph(State)

Passo 3: Criar o Node de Chatbot Utilize o modelo de LLM Claude para responder às perguntas.

from langchain_anthropic import ChatAnthropic
llm = ChatAnthropic(model="claude-3-5-sonnet-20240620")

def chatbot(state: State):
    return {"messages": [llm.invoke(state["messages"])]}

graph_builder.add_node("chatbot", chatbot)
graph_builder.add_edge(START, "chatbot")
graph_builder.add_edge("chatbot", END)

Passo 4: Compilar e Visualizar o Gráfico

graph = graph_builder.compile()
from IPython.display import Image, display
display(Image(graph.get_graph().draw_mermaid_png()))

Passo 5: Adicionar Ferramentas para Buscar na Web Adicione o TavilySearch para buscar respostas que o chatbot não saiba.

from langchain_community.tools.tavily_search import TavilySearchResults
tool = TavilySearchResults(max_results=2)
llm_with_tools = llm.bind_tools([tool])

def chatbot_with_tools(state: State):
    return {"messages": [llm_with_tools.invoke(state["messages"])]}

graph_builder.add_node("chatbot_with_tools", chatbot_with_tools)

Passo 6: Definir Lógica Condicional Implemente uma lógica que roteie o fluxo de controle, usando ferramentas ou respostas diretas, conforme necessário.

def route_tools(state: State):
    ai_message = state["messages"][-1]
    if hasattr(ai_message, "tool_calls") and len(ai_message.tool_calls) > 0:
        return "tools"
    return "__end__"

graph_builder.add_conditional_edges("chatbot_with_tools", route_tools, {"tools": "tools", "__end__": END})
graph_builder.add_edge("tools", "chatbot_with_tools")

Passo 7: Executar o Agente

def stream_graph_updates(user_input: str):
    for event in graph.stream({"messages": [("user", user_input)]}):
        for value in event.values():
            print("Assistant:", value["messages"][-1].content)

while True:
    user_input = input("User: ")
    if user_input.lower() in ["quit", "exit", "q"]:
        break
    stream_graph_updates(user_input)

Esse é um exemplo de como criar um agente de IA básico usando LangGraph, capaz de responder a perguntas e buscar informações na web quando necessário.

Considerações Finais

Criar um agente de IA com o LangChain em Python é uma tarefa flexível e modular. O uso de ferramentas e modelos de linguagem permite a construção de agentes inteligentes que podem realizar ações úteis, automatizar processos e interagir com usuários de maneira eficaz. O LangChain facilita o desenvolvimento desses agentes com uma arquitetura escalável e fácil de usar, ideal para empresas e desenvolvedores que buscam soluções de IA.

---

Palavras-chave: agente de IA, LangGraph, chatbot, integração de ferramentas, programação em Python, construção de chatbots, inteligência artificial, guia LangGraph