Tokia
Entrar
Documentação
⌘K

LangChain / LangGraph

O LangChain e o framework mais usado para construir aplicacoes de IA em Python. Como o Tokia e OpenAI-compatible, basta usar ChatOpenAI com o endpoint Tokia — nenhuma dependencia extra.

Instalacao

bash
pip install langchain langchain-openai

Configuracao basica

python
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    api_key="sk-...",
    base_url="https://api.usetokia.com/v1",
    model="gpt-4o-mini",
    temperature=0.3,
)

Chamada basica (invoke)

python
from langchain_core.messages import HumanMessage, SystemMessage

response = llm.invoke([
    SystemMessage(content="Responda em pt-BR, de forma concisa."),
    HumanMessage(content="Qual a capital da Franca?"),
])
print(response.content)

Streaming

python
for chunk in llm.stream("Liste 5 frutas tropicais brasileiras"):
    print(chunk.content, end="", flush=True)

Chains (Prompt + LLM + Parser)

O padrao mais comum do LangChain: compor prompt template, modelo e parser de saida usando o operador pipe (|):

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

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

chain = prompt | llm | StrOutputParser()

resultado = chain.invoke({
    "area": "direito tributario",
    "pergunta": "ICMS pode incidir sobre frete?"
})
print(resultado)

Structured Output

Force o modelo a retornar um schema especifico com with_structured_output:

python
from pydantic import BaseModel, Field

class Analise(BaseModel):
    sentimento: str = Field(description="positivo, negativo ou neutro")
    resumo: str = Field(description="resumo em 1 frase")
    score: float = Field(description="confianca de 0 a 1")

structured_llm = llm.with_structured_output(Analise)
result = structured_llm.invoke("Adorei o produto, entrega rapida e preco justo!")
print(result.sentimento, result.score)

Embeddings

Para RAG e busca semantica, use OpenAIEmbeddings com o endpoint Tokia:

python
from langchain_openai import OpenAIEmbeddings

embeddings = OpenAIEmbeddings(
    api_key="sk-...",
    base_url="https://api.usetokia.com/v1",
    model="text-embedding-3-small",
)

vetores = embeddings.embed_documents([
    "Como funciona o ICMS?",
    "Prazo de entrega do produto",
    "Politica de devolucao",
])
print(f"Dimensoes: {len(vetores[0])}")

RAG (Retrieval-Augmented Generation)

Exemplo minimo de RAG com documentos em memoria:

python
from langchain_core.documents import Document
from langchain_community.vectorstores import FAISS
from langchain.chains.combine_documents import create_stuff_documents_chain
from langchain.chains import create_retrieval_chain
from langchain_core.prompts import ChatPromptTemplate

docs = [
    Document(page_content="O frete e gratis para compras acima de R$ 200."),
    Document(page_content="Devolucoes devem ser feitas em ate 30 dias."),
    Document(page_content="Parcelamos em ate 12x sem juros no cartao."),
]

vectorstore = FAISS.from_documents(docs, embeddings)
retriever = vectorstore.as_retriever()

prompt = ChatPromptTemplate.from_messages([
    ("system", "Responda usando APENAS o contexto fornecido:\n\n{context}"),
    ("human", "{input}"),
])

chain = create_retrieval_chain(
    retriever,
    create_stuff_documents_chain(llm, prompt),
)

result = chain.invoke({"input": "Qual o prazo de devolucao?"})
print(result["answer"])

Tool Calling

python
from langchain_core.tools import tool

@tool
def consultar_saldo(user_id: str) -> str:
    """Consulta o saldo atual do usuario."""
    return "R$ 150,00"

@tool
def listar_modelos(categoria: str) -> str:
    """Lista modelos disponiveis por categoria."""
    return "gpt-4o-mini, claude-sonnet-46, gemini-2.5-flash"

llm_with_tools = llm.bind_tools([consultar_saldo, listar_modelos])
response = llm_with_tools.invoke("Qual meu saldo?")
print(response.tool_calls)

LangGraph (agentes)

Para fluxos mais complexos com estado e decisoes, use LangGraph. O modelo LLM e o mesmo ChatOpenAI configurado acima — o LangGraph so gerencia o grafo de execucao.

bash
pip install langgraph
python
from langgraph.prebuilt import create_react_agent

agent = create_react_agent(llm, tools=[consultar_saldo, listar_modelos])

result = agent.invoke({
    "messages": [{"role": "user", "content": "Qual meu saldo e quais modelos de chat tem?"}]
})
for msg in result["messages"]:
    print(f"{msg.type}: {msg.content}")

Modelos disponiveis

Troque o parametro model para acessar qualquer modelo do catalogo Tokia. Todos passam pelo mesmo endpoint.

  • gpt-4o-mini — rapido, barato, uso geral
  • claude-sonnet-46 — raciocinio avancado, texto longo
  • deepseek-v3-0324 — otimo para codigo
  • gemini-2.5-flash — contexto longo (1M tokens)

Proximos passos

  • Cookbook — receitas completas com RAG, chatbot, agentes
  • Tool Calling — guia detalhado de function calling
  • Modelos — catalogo completo