# pip install langchain langchain-openai
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
# 1) Modelo
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
# 2) Prompt
prompt = ChatPromptTemplate.from_messages( e guia de .
---
## Blocos de Construção que Você Usará em 80% do Tempo
### 1)  e Análise de Saída
- Use `ChatPromptTemplate` para  estruturados.
- Analise as saídas com `StrOutputParser` ou analisadores JSON para respostas tipadas.
`python
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-4o-mini")
prompt = ChatPromptTemplate.from_template(
"""
Resuma o texto a seguir em 3 tópicos:
---
{text}
"""
)
parser = StrOutputParser
chain = prompt | llm | parser
summary = chain.invoke({"text": "LangChain ajuda a construir aplicativos LLM com RAG e ferramentas."})
print(summary)

# pip install faiss-cpu tiktoken
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_community.vectorstores import FAISS
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_core.prompts import ChatPromptTemplate
# Preparar documentos
texts = .
---
## Do Protótipo à Produção: Um Plano Passo a Passo
### Passo 1: Defina a História do Usuário
- Quem é o usuário? Que trabalho eles estão tentando realizar?
- Exemplo: “Um agente de suporte que responde a perguntas sobre produtos a partir de documentos internos e tickets recentes.”
### Passo 2: Escolha a  Mínima Viável
- Modelo: Escolha um modelo confiável e com preço razoável (por exemplo, GPT-4o-mini ou um modelo aberto de ponta).
- Dados: Decida se você precisa de RAG agora. Se sim, comece com FAISS localmente.
- I/O: Use LCEL para iteração rápida; evite código de cola personalizado.
### Passo 3: Implemente um  RAG Limpo
- Divida os documentos corretamente.
- Indexe as incorporações ().
- Faça o  com contexto e citações.
- Adicione uma proteção para evitar alucinações quando nenhum contexto relevante for encontrado.
`python
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
qa_prompt = ChatPromptTemplate.from_template(
"""
Responda à pergunta usando APENAS o CONTEXTO abaixo. Se a resposta não estiver
no contexto, diga "Eu não sei". Inclua IDs de documentos citados.
CONTEXTO:
{context}
PERGUNTA: {question}
"""
)
parser = StrOutputParser
rag_chain = (RunnableParallel(context=retriever, question=RunnableLambda(lambda x: x.
### Passo 5: Saídas Tipadas e Validação
- Use `PydanticOutputParser` ou esquema JSON para impor a estrutura para respostas de API.
- Valide os campos para detectar o desvio do modelo.
### Passo 6: Ferramentas e Chamada de Função para Tarefas Reais
- Introduza ferramentas com moderação.
- Ferramentas comuns: calculadora, pesquisa na web, executor de consulta SQL, executor de código.
- Descreva claramente os recursos da ferramenta em .
### Passo 7: Reforço
- Limite de taxa e estratégias de repetição.
- Tempos limite e disjuntores.
- Filtros de segurança e verificações de conteúdo.
### Passo 8: Avaliação e Melhoria Contínua
- Teste com conjuntos de dados  (entrada → saída esperada).
- Avalie a fidelidade, a integridade da resposta e a precisão da citação.
- Meça a taxa de acerto da recuperação e a latência.
---
## Padrões Comuns e Armadilhas
- Comece simples:  antes de agentes. Você obterá previsibilidade e menor custo.
-  é importante: Ajustar o tamanho/sobreposição do  pode mudar a qualidade da recuperação mais do que a troca do modelo.
- Vazamento de : Não coloque tudo na cozinha em  do sistema; mantenha-os focados.
- Determinismo: Defina `temperature=0` para avaliação e fluxos de trabalho críticos.
- UX de : Transmita  para a interface do usuário enquanto o resto do sistema busca ativos ou pré-carrega o contexto.
- Saídas estruturadas: Use analisadores para tornar a integração  indolor.
---
## Um Mini Projeto Completo: Perguntas e Respostas sobre Documentos com Citações
Este exemplo une tudo: ingestão, RAG, geração de resposta e .
`python
# pip install langchain langchain-openai faiss-cpu tiktoken
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import FAISS
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnableParallel, RunnableLambda
# 1) Ingerir
corpus = {
"pricing": "Nosso plano Pro suporta 1 milhão de  de contexto e inclui suporte prioritário.",
"limits": "O limite de taxa da API é de 60 solicitações por minuto para usuários Pro.",
"security": "Armazenamos  por 30 dias, a menos que o registro seja desativado pelo administrador.",
}
splitter = RecursiveCharacterTextSplitter(chunk_size=300, chunk_overlap=50)
all_chunks, ids = [], []
for doc_id, text in corpus.items:
for i, chunk in enumerate(splitter.split_text(text)):
all_chunks.append(chunk)
ids.append(f"{doc_id}-{i}")
# 2) Indexar
db = FAISS.from_texts(all_chunks, OpenAIEmbeddings)
retriever = db.as_retriever(k=4)
# 3) 
prompt = ChatPromptTemplate.from_template(
"""
Você é um assistente de suporte. Use o CONTEXTO para responder.
Se não tiver certeza, diga "Eu não sei". Inclua citações de IDs de origem.
CONTEXTO:
{context}
PERGUNTA: {question}
"""
)
# 4) Modelo e analisador
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
parser = StrOutputParser
# 5) Compor 
rag = (
RunnableParallel(
context=retriever,
question=RunnableLambda(lambda x: x["question"]) # passagem
)
| prompt
| llm
| parser
)
# 6) Faça uma pergunta
for chunk in rag.stream({"question": "Quais são os limites de taxa Pro e a retenção de ?"}):
print(chunk, end="", flush=True)