LangChain Core
     |
     +-- LangChain (Python/JS)
     |
     +-- LangSmith (Observabilidade)
     |
     +-- LangServe (Deploy)
     |
     +-- LangGraph (Agentes)

# LLMs (texto -> texto)
from langchain_openai import OpenAI

llm = OpenAI(model="gpt-3.5-turbo-instruct")
response = llm.invoke("Explique o que e machine learning")

# Chat Models (mensagens -> mensagens)
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, SystemMessage

chat = ChatOpenAI(model="gpt-4")
messages = [
    SystemMessage(content="Voce e um assistente tecnico."),
    HumanMessage(content="O que e RAG?")
]
response = chat.invoke(messages)

# Embeddings
from langchain_openai import OpenAIEmbeddings

embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vector = embeddings.embed_query("texto para embedding")

from langchain_core.prompts import PromptTemplate, ChatPromptTemplate

# Template simples
template = PromptTemplate.from_template(
    "Traduza o seguinte texto para {idioma}: {texto}"
)
prompt = template.format(idioma="ingles", texto="Ola mundo")

# Template de chat
chat_template = ChatPromptTemplate.from_messages([
    ("system", "Voce e um assistente que responde em {estilo}."),
    ("human", "{pergunta}")
])
messages = chat_template.format_messages(
    estilo="formato tecnico",
    pergunta="Como funciona TCP/IP?"
)

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

# LCEL (LangChain Expression Language)
prompt = ChatPromptTemplate.from_template("Conte uma piada sobre {topico}")
model = ChatOpenAI()
parser = StrOutputParser()

# Chain usando pipe operator
chain = prompt | model | parser

# Executar
response = chain.invoke({"topico": "programacao"})

from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
from langchain_community.document_loaders import TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter

# 1. Carregar documentos
loader = TextLoader("documento.txt")
documents = loader.load()

# 2. Dividir em chunks
splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
chunks = splitter.split_documents(documents)

# 3. Criar vector store
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(chunks, embeddings)

# 4. Criar retriever
retriever = vectorstore.as_retriever(
    search_type="similarity",
    search_kwargs={"k": 3}
)

# 5. Buscar documentos
docs = retriever.invoke("minha pergunta")

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

# Memoria em buffer
memory = ConversationBufferMemory()

chain = ConversationChain(
    llm=ChatOpenAI(),
    memory=memory
)

# Multiplas interacoes mantendo contexto
response1 = chain.invoke({"input": "Meu nome e Carlos"})
response2 = chain.invoke({"input": "Qual e meu nome?"})
# Resposta: "Seu nome e Carlos"

from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser

# 1. Carregar e processar documentos
loader = PyPDFLoader("manual_empresa.pdf")
pages = loader.load()

splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200
)
chunks = splitter.split_documents(pages)

# 2. Criar vector store
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(chunks, embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})

# 3. Definir prompt
template = """Responda a pergunta baseado no contexto abaixo.
Se nao souber a resposta, diga que nao sabe.

Contexto:
{context}

Pergunta: {question}

Resposta:"""

prompt = ChatPromptTemplate.from_template(template)

# 4. Criar chain RAG
def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

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

rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | prompt
    | model
    | StrOutputParser()
)

# 5. Usar
response = rag_chain.invoke("Qual e a politica de ferias?")

import os

# Configurar LangSmith
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_API_KEY"] = "sua-api-key"
os.environ["LANGCHAIN_PROJECT"] = "meu-projeto"

# Agora todas as chains sao automaticamente rastreadas
chain.invoke({"input": "teste"})
# Visualize traces em: https://smith.langchain.com

# Exemplo com streaming
for chunk in rag_chain.stream("minha pergunta"):
    print(chunk, end="", flush=True)