Conecte o LangChain em quatro linhas
Se você quer usar modelos open source do LangChain sem hospedar nada, o caminho mais curto é uma API compatível com OpenAI. A classe de chat OpenAI do LangChain não se importa com quem responde, desde que o endpoint fale o mesmo protocolo. Você altera a base URL e a chave, e o resto das suas cadeias, prompts e agentes permanece igual.
Este serviço hospeda um único modelo de pesos abertos, executado por um provedor independente e ajustado para responder sem recusas de conteúdo para uso adulto legal. Não é a API oficial de nenhum fornecedor de modelo e não é um roteador entre fornecedores. Instale o pacote e crie o objeto do modelo:
pip install langchain-openai langchain-core
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.uncensoredmodelhub.com/v1",
api_key="YOUR_API_KEY",
temperature=0.7,
)
print(llm.invoke("Give me three names for a fantasy tavern.").content)
Essa é a conexão inteira. Mantenha a chave em uma variável de ambiente em projetos reais e leia-a com os.environ em vez de escrevê-la no arquivo. Se você ainda não tem uma chave, a página de chaves mostra como entrar e reivindicar $0,50 de crédito de teste, sem necessidade de cartão.
Node.js e LangChain.js
O pacote JavaScript segue a mesma ideia, com a base URL passada por meio de um objeto de configuração.
import { ChatOpenAI } from "@langchain/openai";
const llm = new ChatOpenAI({
model: "uncensored",
apiKey: process.env.API_KEY,
temperature: 0.7,
configuration: { baseURL: "https://api.uncensoredmodelhub.com/v1" },
});
const reply = await llm.invoke("Summarize the plot of a heist film in two lines.");
console.log(reply.content);
Se você vir um 404 ou uma página HTML no erro, a base URL geralmente está incorreta. Ela deve terminar em /v1. Os dois endpoints por trás disso são POST /v1/chat/completions e GET /v1/models, e nada mais é necessário para o modelo de chat do LangChain.
Um modelo open source no LangChain é melhor hospedado ou local?
O LangChain também pode executar modelos open em sua própria máquina, por exemplo, através do Ollama ou de um servidor local. Essa rota tem vantagens reais, e é honesto dizer isso. Modelos locais não têm custo por token, funcionam offline e mantêm todos os bytes no seu hardware. O preço é o hardware: você precisa de memória de GPU suficiente para o modelo que escolher, mantém o runtime e o throughput é limitado pela sua máquina.
| Pergunta | Servidor local | Esta API hospedada |
|---|---|---|
| Custo inicial | Hardware ou GPU alugada | Nenhum; crédito pré-pago a partir de $20 |
| Custo por token | Nenhum, mas desgaste de energia e hardware | $0,15 por 1M de entrada, $0,50 por 1M de saída |
| Janela de contexto | Depende da memória disponível | 100.000 tokens |
| Concorrência | Depende da sua configuração | 8 para uma chave completa |
| Localização dos dados | Sua máquina | Hospedado; prompts não usados para treinamento |
Um padrão comum é prototipar contra o endpoint hospedado e decidir, com contagens reais de tokens, se uma implantação local faz sentido. Como ambos os lados falam o protocolo OpenAI, a troca é uma alteração de linha única em base_url, e as cadeias que você construiu permanecem intactas. A página sobre o que é um modelo sem censura explica o que os ajustes mudam no comportamento.
Ferramentas e um agente simples
A chamada de ferramentas passa pelo campo tools no estilo OpenAI normal, e o bind_tools do LangChain constrói isso para você a partir de uma função Python decorada. O modelo retorna solicitações de chamada de ferramenta, e os resultados voltam como mensagens role: "tool".
from langchain_core.tools import tool
from langgraph.prebuilt import create_react_agent
@tool
def word_count(text: str) -> int:
'''Count the words in a piece of text.'''
return len(text.split())
agent = create_react_agent(llm, [word_count])
result = agent.invoke({"messages": [("user", "How many words are in 'the quick brown fox jumps'?")]})
print(result["messages"][-1].content)
O loop do agente chama o modelo, executa a ferramenta quando solicitado e envia a saída de volta até que o modelo responda em texto simples. Duas cautelas se aplicam. Forneça uma docstring para cada ferramenta escrita para o modelo, porque esse é o texto que ele lê para escolher uma ferramenta. E defina um limite de recursão nos agentes para que uma execução confusa não continue gastando crédito; o LangGraph aceita um recursion_limit na configuração.
Para controle direto sem um agente, use llm.bind_tools([word_count]) e inspecione .tool_calls na mensagem retornada você mesmo.
Saída estruturada com modo JSON
Para tarefas de extração, passe o parâmetro do modo JSON através de bind. O prompt deve dizer ao modelo quais chaves você quer, pois o modo JSON apenas o empurra a produzir um objeto JSON válido.
import json
from langchain_core.prompts import ChatPromptTemplate
json_llm = llm.bind(response_format={"type": "json_object"})
prompt = ChatPromptTemplate.from_messages([
("system", "Return a JSON object with keys title, genre and summary."),
("human", "{idea}"),
])
chain = prompt | json_llm
raw = chain.invoke({"idea": "A lighthouse keeper finds a door in the sea floor."})
data = json.loads(raw.content)
Valide o resultado com Pydantic ou uma verificação simples de chave antes de usá-lo. O modo não impõe um schema, então um campo ausente é possível, e uma nova tentativa com um prompt mais claro geralmente corrige isso.
Streaming e concorrência
O streaming roda sobre eventos enviados pelo servidor e funciona com o método stream padrão. O uso é enviado no final do stream.
for chunk in llm.stream("Write a four-line poem about rain on a tin roof."):
print(chunk.content, end="", flush=True)
Quando você processa muitos itens, batch os executa em paralelo, e é aqui que os limites importam. Uma chave completa permite 8 requisições simultâneas e 300 requisições por minuto. Uma chave de teste permite 2 e 60. Uma solicitação streaming mantém seu slot até o stream terminar. Passe um limite para que o LangChain nunca exceda o que sua chave permite:
prompts = [f"Write a one-line tagline for product {i}." for i in range(40)]
results = llm.batch(prompts, config={"max_concurrency": 6})
Se você ainda vir HTTP 429, o código de erro indica qual limite você atingiu: rate_limited para requisições por minuto, concurrency para muitos ao mesmo tempo. Um 429 com um cabeçalho Retry-After: 5 marca sobrecarga temporária. ChatOpenAI tem uma opção max_retries que tenta novamente nesses erros com backoff; defina para 3 ou 4 para trabalhos em lote.
Uma cadeia de recuperação sem um endpoint de embeddings
Esta API cobre apenas geração, então uma cadeia de recuperação precisa de dois provedores: um para embeddings e outro para a etapa de chat. O LangChain facilita isso, porque o vector store e o modelo de chat são objetos separados. Use qualquer modelo de embedding que quiser, de uma biblioteca local ou outro serviço, para indexar seus documentos. Em seguida, passe o texto recuperado para o modelo de chat por meio do prompt.
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
prompt = ChatPromptTemplate.from_messages([
("system", "Answer using only the context. If the answer is not there, say so.\n\nContext:\n{context}"),
("human", "{question}"),
])
chain = prompt | llm | StrOutputParser()
answer = chain.invoke({"context": "\n\n".join(top_chunks), "question": "What is the refund window?"})
Aqui top_chunks é o que seu retriever retornou. Mantenha apenas os poucos trechos que importam. Quatro chunks de 300 tokens adicionam 1.200 tokens por chamada, o que é aceitável, mas quarenta chunks adicionam 12.000 e tornam cada requisição dez vezes mais pesada.
Lista de verificação de solução de problemas
- Erros de autenticação: confirme se a chave está em
api_key, não em um parâmetro diferente, e se nenhuma variável de ambienteOPENAI_API_KEYestá substituindo silenciosamente o que você pretendia passar. - Modelo não encontrado: o ID do modelo é exatamente
uncensored. ChameGET /v1/modelspara ver o que o servidor lista. - Argumentos de ferramenta estranhos: leia a string de argumentos bruta, refine a descrição da ferramenta e reduza a temperatura para cerca de 0,2 para execuções de agente.
- Rastreamento e depuração: ative o modo verbose ou debug do LangChain localmente para ver cada prompt enviado e cada resposta recebida.
- Testes repetíveis: passe
seede uma temperatura baixa quando comparar versões de prompt, para que as diferenças venham da sua alteração e não da sorte da amostragem.
Custo de uma carga de trabalho do LangChain
A cobrança é por token a partir do crédito pré-pago. Não há assinatura, requisições falhas ou recusadas não são cobradas, e o crédito nunca expira. Os recarregamentos podem ser qualquer valor inteiro de $20 a $500, por cripto (USDT na rede TRC20, USDC na rede Base), com bônus de 5% a partir de $50, 10% a partir de $100 e 15% a partir de $200. A página de preços tem os detalhes.
Resolva um exemplo. Um bot de suporte responde a 2.000 perguntas em um dia. Cada solicitação envia cerca de 1.500 tokens (prompt do sistema, snippets recuperados, pergunta) e retorna cerca de 250 tokens.
- Entrada: 2.000 x 1.500 = 3.000.000 tokens, então 3 x $0,15 = $0,45.
- Saída: 2.000 x 250 = 500.000 tokens, então 0,5 x $0,50 = $0,25.
- Total: $0,70 por dia para 2.000 respostas, ou $0,00035 cada.
Cadeias de recuperação são onde os custos podem variar, porque cada chunk recuperado extra adiciona tokens de entrada a cada chamada. Registre usage_metadata das respostas, monitore o tamanho médio do prompt e reduza a contagem de chunks antes de escalar. A documentação da API lista todos os parâmetros suportados se você quiser ir além.
