LangChain Tutorial: Guia Completo

LangChain é o framework mais popular para construir aplicações com LLMs. Este tutorial cobre tudo que você precisa para começar.

O que é LangChain?

LangChain é um framework que facilita a construção de aplicações com LLMs. Ele fornece:

• Abstrações para diferentes LLMs
• Componentes para RAG
• Ferramentas para criar agentes
• Memória para conversas
• Integrações com centenas de serviços

Setup

# Instalar LangChain
pip install langchain langchain-openai langchain-community

# Configurar API key
export OPENAI_API_KEY="sk-..."

Conceitos Básicos

1. Chat Models

from langchain_openai import ChatOpenAI

# Criar modelo
llm = ChatOpenAI(
    model="gpt-4",
    temperature=0.7
)

# Invocar
response = llm.invoke("Olá! Como você está?")
print(response.content)

2. Prompt Templates

from langchain.prompts import ChatPromptTemplate

# Template simples
template = ChatPromptTemplate.from_messages([
    ("system", "Você é um assistente especializado em {tema}."),
    ("user", "{pergunta}")
])

# Usar template
messages = template.format_messages(
    tema="Python",
    pergunta="O que são list comprehensions?"
)

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

3. Chains

from langchain.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
from langchain.schema.output_parser import StrOutputParser

# Criar chain com LCEL (LangChain Expression Language)
prompt = ChatPromptTemplate.from_template(
    "Explique {conceito} em uma frase simples."
)
llm = ChatOpenAI()
output_parser = StrOutputParser()

# Chain: prompt → llm → parser
chain = prompt | llm | output_parser

# Invocar
result = chain.invoke({"conceito": "machine learning"})
print(result)

4. Chains Complexas

from langchain.schema.runnable import RunnablePassthrough

# Chain que combina múltiplos passos
def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

# RAG chain
rag_chain = (
    {
        "context": retriever | format_docs,
        "question": RunnablePassthrough()
    }
    | prompt
    | llm
    | output_parser
)

# Usar
answer = rag_chain.invoke("Qual o prazo de devolução?")

RAG com LangChain

Carregar Documentos

from langchain.document_loaders import (
    PyPDFLoader,
    TextLoader,
    WebBaseLoader,
    DirectoryLoader
)

# PDF
loader = PyPDFLoader("documento.pdf")
docs = loader.load()

# Página web
loader = WebBaseLoader("https://exemplo.com")
docs = loader.load()

# Diretório inteiro
loader = DirectoryLoader(
    "./docs/",
    glob="**/*.txt",
    loader_cls=TextLoader
)
docs = loader.load()

Dividir em Chunks

from langchain.text_splitter import RecursiveCharacterTextSplitter

splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
    length_function=len,
    separators=["\n\n", "\n", ".", " "]
)

chunks = splitter.split_documents(docs)
print(f"{len(chunks)} chunks criados")

Criar Vector Store

from langchain_openai import OpenAIEmbeddings
from langchain.vectorstores import Chroma

# Embeddings
embeddings = OpenAIEmbeddings()

# Vector store
vectorstore = Chroma.from_documents(
    documents=chunks,
    embedding=embeddings,
    persist_directory="./chroma_db"
)

# Retriever
retriever = vectorstore.as_retriever(
    search_type="similarity",
    search_kwargs={"k": 5}
)

Chain de Q&A

from langchain.chains import RetrievalQA

qa_chain = RetrievalQA.from_chain_type(
    llm=ChatOpenAI(model="gpt-4"),
    chain_type="stuff",
    retriever=retriever,
    return_source_documents=True
)

result = qa_chain.invoke({"query": "Qual o prazo de garantia?"})
print(result["result"])
print(result["source_documents"])

Memória

from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain

# Memória simples (guarda tudo)
memory = ConversationBufferMemory()

# Chain com memória
conversation = ConversationChain(
    llm=ChatOpenAI(),
    memory=memory,
    verbose=True
)

# Conversar
conversation.predict(input="Olá! Meu nome é João.")
conversation.predict(input="Qual é meu nome?")
# → "Seu nome é João."

Tipos de Memória

from langchain.memory import (
    ConversationBufferMemory,      # Guarda tudo
    ConversationBufferWindowMemory, # Últimas N mensagens
    ConversationSummaryMemory,      # Resume conversa
    ConversationKGMemory            # Knowledge Graph
)

# Buffer Window (últimas 5 mensagens)
memory = ConversationBufferWindowMemory(k=5)

# Summary (resume para economizar tokens)
memory = ConversationSummaryMemory(llm=ChatOpenAI())

Agentes

from langchain.agents import create_openai_tools_agent, AgentExecutor
from langchain.tools import tool
from langchain import hub

# Definir ferramenta
@tool
def calculator(expression: str) -> str:
    """Calcula expressões matemáticas."""
    return str(eval(expression))

@tool  
def search_web(query: str) -> str:
    """Busca informações na web."""
    # Implementar busca real
    return f"Resultados para: {query}"

tools = [calculator, search_web]

# Criar agente
prompt = hub.pull("hwchase17/openai-tools-agent")
llm = ChatOpenAI(model="gpt-4")

agent = create_openai_tools_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# Usar
result = executor.invoke({"input": "Quanto é 15% de 350?"})
print(result["output"])

LangChain Expression Language (LCEL)

Nova sintaxe declarativa para criar chains:

from langchain_openai import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema.output_parser import StrOutputParser

# LCEL usa | para conectar componentes
chain = (
    ChatPromptTemplate.from_template("Conte uma piada sobre {tema}")
    | ChatOpenAI()
    | StrOutputParser()
)

# Invoke
result = chain.invoke({"tema": "programadores"})

# Stream
for chunk in chain.stream({"tema": "programadores"}):
    print(chunk, end="")

# Batch
results = chain.batch([
    {"tema": "python"},
    {"tema": "javascript"},
    {"tema": "rust"}
])

# Async
result = await chain.ainvoke({"tema": "ia"})

Callbacks e Tracing

from langchain.callbacks import StdOutCallbackHandler

# Callback para ver o que está acontecendo
handler = StdOutCallbackHandler()

chain.invoke(
    {"tema": "python"},
    config={"callbacks": [handler]}
)

# LangSmith para tracing em produção
# export LANGCHAIN_TRACING_V2=true
# export LANGCHAIN_API_KEY=...

Integração com Outros Serviços

# Vector Stores
from langchain.vectorstores import (
    Chroma,
    Pinecone,
    Weaviate,
    FAISS,
    Qdrant
)

# LLMs
from langchain_openai import ChatOpenAI
from langchain_anthropic import ChatAnthropic
from langchain_google_genai import ChatGoogleGenerativeAI

# Document Loaders
from langchain.document_loaders import (
    PyPDFLoader,
    NotionDBLoader,
    SlackDirectoryLoader,
    GitHubIssuesLoader
)

# Tools
from langchain.tools import (
    WikipediaQueryRun,
    DuckDuckGoSearchRun,
    ShellTool,
    PythonREPLTool
)

Dicas de Produção

1. USE ASYNC
   - Melhor performance
   - await chain.ainvoke(...)

2. CACHING
   from langchain.cache import InMemoryCache
   langchain.llm_cache = InMemoryCache()

3. RATE LIMITING
   - Use max_retries e request_timeout
   
4. FALLBACKS
   chain.with_fallbacks([fallback_chain])

5. TRACING
   - LangSmith para debug
   - Logs detalhados em produção

6. STREAMING
   - Sempre que possível para UX

Estrutura de Projeto

my_ai_app/
├── src/
│   ├── chains/
│   │   ├── qa_chain.py
│   │   └── summary_chain.py
│   ├── agents/
│   │   └── research_agent.py
│   ├── tools/
│   │   ├── search.py
│   │   └── calculator.py
│   ├── loaders/
│   │   └── document_loader.py
│   └── prompts/
│       └── templates.py
├── data/
│   └── vectorstore/
├── tests/
├── .env
└── requirements.txt