LangChain e LangGraph

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

# Com todas as integracoes
pip install langchain[all]

# LangGraph
pip install langgraph

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)

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?"
})

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..."})

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"
)

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))

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?"})

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()

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?")]
})

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")