LangChain e LangGraph

LangChain e um framework para desenvolvimento de aplicacoes com LLMs. LangGraph estende suas capacidades para criar agentes e workflows complexos.

LangChain - Visao Geral

LangChain fornece abstracoes para trabalhar com modelos de linguagem de forma modular e composavel.

Componentes Principais

Componente	Descricao
Models	Interfaces para LLMs (OpenAI, Anthropic, etc.)
Prompts	Templates e gerenciamento de prompts
Chains	Sequencias de chamadas encadeadas
Memory	Persistencia de contexto entre interacoes
Agents	Sistemas que decidem acoes dinamicamente
Tools	Funcoes que agentes podem executar
Retrievers	Busca em bases de conhecimento

Instalacao

# Instalacao basica
pip install langchain langchain-openai langchain-anthropic

# Com todas as integracoes
pip install langchain[all]

# LangGraph
pip install langgraph

Exemplos Praticos

Chat Simples

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, SystemMessage

model = ChatOpenAI(model="gpt-4o")

messages = [
    SystemMessage(content="Voce e um especialista em DevOps."),
    HumanMessage(content="Explique CI/CD.")
]

response = model.invoke(messages)
print(response.content)

Prompt Templates

from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_messages([
    ("system", "Voce e um especialista em {area}."),
    ("human", "{pergunta}")
])

chain = prompt | model

response = chain.invoke({
    "area": "Kubernetes",
    "pergunta": "O que sao Pods?"
})

Chains com LCEL

LangChain Expression Language (LCEL) permite compor chains de forma declarativa:

from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_template(
    "Resuma em 3 pontos: {texto}"
)

chain = prompt | model | StrOutputParser()

resultado = chain.invoke({"texto": "Texto longo aqui..."})

Memory - Historico de Conversas

from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory

history = ChatMessageHistory()

chain_with_history = RunnableWithMessageHistory(
    chain,
    lambda session_id: history,
    input_messages_key="input",
    history_messages_key="history"
)

Agents e Tools

Agentes podem usar ferramentas para realizar tarefas.

Criando Tools

from langchain_core.tools import tool

@tool
def buscar_clima(cidade: str) -> str:
    """Busca o clima atual de uma cidade."""
    # Implementacao real aqui
    return f"Clima em {cidade}: 25C, ensolarado"

@tool
def calcular(expressao: str) -> str:
    """Calcula uma expressao matematica."""
    return str(eval(expressao))

Configurando o Agent

from langchain_openai import ChatOpenAI
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain_core.prompts import ChatPromptTemplate

tools = [buscar_clima, calcular]

prompt = ChatPromptTemplate.from_messages([
    ("system", "Voce e um assistente util."),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}")
])

model = ChatOpenAI(model="gpt-4o")
agent = create_tool_calling_agent(model, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

result = executor.invoke({"input": "Qual o clima em Sao Paulo?"})

LangGraph - Workflows Complexos

LangGraph permite criar grafos de execucao com estados e condicoes.

Conceitos

Conceito	Descricao
State	Dados compartilhados entre nos
Nodes	Funcoes que processam o estado
Edges	Conexoes entre nos
Conditional Edges	Roteamento baseado em condicoes

Exemplo: Workflow de Revisao

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

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

def revisar(state: State) -> State:
    # Logica de revisao
    mensagem = state["messages"][-1].content
    aprovado = len(mensagem) > 10  # Exemplo simples
    return {"aprovado": aprovado}

def aprovar(state: State) -> State:
    return {"messages": [("assistant", "Conteudo aprovado!")]}

def rejeitar(state: State) -> State:
    return {"messages": [("assistant", "Conteudo rejeitado. Revise.")]}

def roteador(state: State) -> str:
    return "aprovar" if state["aprovado"] else "rejeitar"

# Construir o grafo
builder = StateGraph(State)
builder.add_node("revisar", revisar)
builder.add_node("aprovar", aprovar)
builder.add_node("rejeitar", rejeitar)

builder.add_edge(START, "revisar")
builder.add_conditional_edges("revisar", roteador)
builder.add_edge("aprovar", END)
builder.add_edge("rejeitar", END)

graph = builder.compile()

Agentes com LangGraph

from langgraph.prebuilt import create_react_agent

tools = [buscar_clima, calcular]
model = ChatOpenAI(model="gpt-4o")

agent = create_react_agent(model, tools)

result = agent.invoke({
    "messages": [("human", "Quanto e 15 * 7?")]
})

Integracao com Bancos Vetoriais

from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import Chroma

embeddings = OpenAIEmbeddings()

# Criar vectorstore
vectorstore = Chroma.from_texts(
    texts=["Documento 1...", "Documento 2..."],
    embedding=embeddings
)

# Buscar documentos similares
retriever = vectorstore.as_retriever()
docs = retriever.invoke("minha pergunta")

Boas Praticas

Use LCEL: Prefira LangChain Expression Language para chains
Streaming: Implemente streaming para melhor UX
Fallbacks: Configure modelos alternativos
Observabilidade: Use LangSmith para debugging
Modularidade: Mantenha tools e chains separados

Recursos

LangChain Documentation
LangGraph Documentation
LangSmith - Observabilidade
LangChain Hub - Prompts compartilhados

On this page