PT ▾

Proxy LLM sem censura pronto para usarhttps://api.llmproxyapi.com/v1

LangChain com LLM local ou endpoint hospedado

Para executar LangChain com código de estilo de LLM local, você só precisa de uma classe de chat que aceite uma base URL personalizada. Se você não tiver GPU ou não quiser cuidar de uma, a mesma classe pode apontar para um endpoint OpenAI-compatível hospedado, e suas cadeias não mudam.

Plataforma desktop e cloud isométrica unidas por uma cadeia de links luminosos, conectando modelos locais e hospedados

Local ou hospedado: escolha pela restrição que mais incomoda

Pessoas que buscam LangChain com um modelo local geralmente querem uma das três coisas: privacidade, sem cobrança por token ou independência de um fornecedor. Um modelo na sua própria máquina, servido por uma ferramenta como Ollama ou llama.cpp, oferece tudo isso se você tiver hardware que possa executá-lo a uma velocidade utilizável. A troca é o tempo de configuração, os limites de memória e a velocidade de qualquer GPU ou CPU que você possua.

Um endpoint hospedado troca isso por um pequeno custo de uso. Você envia prompts pela rede e o modelo é executado no hardware de outra pessoa. Aqui isso significa um modelo de pesos abertos, ajustado para responder sem recusas de conteúdo para uso adulto legal, servido por meio de uma API compatível com OpenAI. Os prompts não são usados para treinamento, mas eles saem da sua máquina, então um serviço hospedado é a resposta errada se a sua regra é que os dados nunca devem sair dela.

O que é útil para um desenvolvedor LangChain é que o código difere pouco. Servidores locais como Ollama e llama.cpp expõem endpoints no estilo OpenAI, e um endpoint hospedado segue o mesmo protocolo. Se você escreve seu app contra ChatOpenAI com uma base URL configurável, você pode desenvolver localmente e alternar para um modelo hospedado com uma variável de ambiente. Isso oferece um híbrido prático: itere em um modelo local pequeno e use o hospedado quando quiser o comportamento de um modelo maior sem precisar de uma GPU.

Conecte ChatOpenAI ao endpoint

Instale o pacote de integração e crie o objeto de modelo com as três configurações necessárias.

pip install langchain-openai langchain-core
import os
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.llmproxyapi.com/v1",
    api_key=os.environ["LLMPROXY_API_KEY"],
    temperature=0.7,
)

print(llm.invoke("Give me three names for a fantasy tavern.").content)

Se isso funcionar, todo o resto funciona da mesma forma. Obtenha sua chave na página de chave de API; novos usuários podem reivindicar $0,50 de crédito de teste com um clique lá após se cadastrar, sem necessidade de cartão. Passe a base URL explicitamente no código em vez de depender de uma variável de ambiente, porque diferentes versões de bibliotecas leem nomes de variáveis diferentes e um fallback silencioso para o host OpenAI padrão enviaria sua chave para o lugar errado.

O nome do modelo é onde as pessoas erram. O único ID aqui é uncensored. Nomes como llama3 ou gpt-4o não serão reconhecidos.

Uma chain com template de prompt

O pipeline padrão de prompt, modelo e output parser roda inalterado. Este exemplo resume texto em um tom escolhido.

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

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a writing assistant. Answer in a {tone} tone."),
    ("human", "Summarize in two sentences:\n\n{text}"),
])

chain = prompt | llm | StrOutputParser()

print(chain.invoke({"tone": "dry", "text": "Long article text goes here..."}))

Para muitas entradas, use batch e limite a simultaneidade. Uma chave completa permite 8 requisições simultâneas e 300 requisições por minuto, então mantenha a configuração em 8 ou menos:

results = chain.batch(
    [{"tone": "dry", "text": t} for t in documents],
    config={"max_concurrency": 6},
)

Uma chave de teste permite apenas 2 requisições simultâneas e 60 por minuto, então use max_concurrency de 2 durante os testes.

Streaming

A API faz streaming via Server-Sent Events, e LangChain expõe isso via stream. Use para interfaces de chat onde o usuário vê a resposta sendo formada.

for chunk in llm.stream("Write a short scene set in a lighthouse."):
    print(chunk.content, end="", flush=True)

Um detalhe prático: uma requisição em streaming mantém seu slot de concorrência até que o stream termine. Se sua UI abandonar um stream pela metade, certifique-se de que o gerador seja fechado, ou sua margem de concorrência diminui. Código assíncrono usa astream da mesma forma.

Tools e agents

Tool calling é suportado: a API aceita tools e tool_choice, faz streaming de tool_calls e recebe resultados como mensagens role: "tool". LangChain envolve isso com bind_tools.

from langchain_core.tools import tool

@tool
def dice(sides: int) -> int:
    "Roll a die with the given number of sides."
    import random
    return random.randint(1, sides)

llm_tools = llm.bind_tools([dice])
msg = llm_tools.invoke("Roll a twenty-sided die for the goblin attack.")
print(msg.tool_calls)

A lista de resultados mostra as chamadas que o modelo deseja, com nomes e argumentos. Execute-as, anexe os resultados como mensagens de ferramenta e chame o modelo novamente, ou deixe um framework de agente como LangGraph executar esse loop. Agentes fazem muitas chamadas por solicitação do usuário, então eles atingem o limite por minuto mais rápido do que cadeias simples. Conte chamadas por execução antes de escolher um nível de simultaneidade.

A janela de contexto é de 100.000 tokens para prompt mais completion, o que é generoso para memória de conversa. Mesmo assim, corte turnos antigos: você paga pelo histórico inteiro em cada chamada a $0,15 por 1M de tokens de entrada.

Saída JSON

O modo JSON está disponível via response_format. No LangChain, passe com model_kwargs ou use o helper de saída estruturada no modo JSON, e descreva os campos no seu prompt.

from pydantic import BaseModel

class Character(BaseModel):
    name: str
    role: str
    secret: str

structured = llm.with_structured_output(Character, method="json_mode")
out = structured.invoke(
    "Invent a character for a mystery story. Reply in JSON with keys name, role, secret."
)
print(out)

Com method="json_mode", o prompt deve instruir o modelo sobre quais chaves produzir; a classe Pydantic então valida o resultado parseado. Mantenha um retry para respostas raras malformadas.

O que não mantém compatibilidade

Dois elementos básicos do LangChain precisam de uma fonte diferente. A API não tem endpoint de embeddings, então OpenAIEmbeddings apontado aqui falhará. Para recuperação sobre seus documentos, use um modelo de embedding local ou outro provedor de embedding e use este endpoint apenas para a etapa de chat. Ele também não tem entrada de imagem ou geração, nem áudio nem ajuste fino, então cadeias de visão e carregadores multimodais estão fora.

Tratamento de erros é principalmente sobre respostas 429. O código rate_limited significa que você excedeu o limite por minuto, concurrency significa muitas chamadas paralelas, e 429 com Retry-After: 5 marca sobrecarga temporária. Defina max_retries no ChatOpenAI para o cliente aguardar e tentar novamente. Requisições falhas e recusadas não são cobradas.

Os headers de resposta ajudam no monitoramento: X-Balance-USD mostra seu crédito restante e X-Request-Id identifica uma chamada para suporte.

Alternando entre local e hospedado com uma variável

Se quiser o setup híbrido, coloque as três configurações em variáveis de ambiente e construa o modelo em uma função. Suas chains importam essa função e nunca mencionam um fornecedor.

import os
from langchain_openai import ChatOpenAI

def make_llm():
    if os.environ.get("LLM_MODE") == "local":
        return ChatOpenAI(
            model=os.environ["LOCAL_MODEL"],
            base_url="http://localhost:11434/v1",
            api_key="not-needed",
        )
    return ChatOpenAI(
        model="uncensored",
        base_url="https://api.llmproxyapi.com/v1",
        api_key=os.environ["LLMPROXY_API_KEY"],
    )

O branch local assume servidor Ollama na porta padrão, expondo rota estilo OpenAI em /v1; verifique a documentação do seu servidor para o endereço e nome do modelo corretos. O comportamento difere entre modelos, então reexecute seus prompts após a troca. Prompt ajustado para um modelo pode ler diferente em outro, e a qualidade de tool calling varia com o modelo, então teste esses caminhos primeiro.

Um workflow sensato é desenvolver prompts contra o modelo hospedado enquanto não tem GPU livre, então decidir quais partes do app devem ficar na sua máquina. Documentos sensíveis podem usar o branch local, e recursos criativos públicos podem usar o hospedado.

Custo e próximos passos

O preço é $0,15 por 1M de tokens de entrada e $0,50 por 1M de tokens de saída, a partir de crédito pré-pago sem assinatura. Uma chamada de cadeia com 2.000 tokens de entrada e 500 tokens de saída custa 2.000 x $0,15 / 1M + 500 x $0,50 / 1M = $0,0003 + $0,00025 = $0,00055. Mil chamadas assim custam $0,55. Recargas variam de $20 a $500 por cripto (USDT em TRC20, USDC em Base), com um bônus de 5% a partir de $50, 10% a partir de $100 e 15% a partir de $200. Detalhes estão na página de preços.

Para uma visão HTTP simples da mesma API, leia o quickstart. O site também tem uma visão geral curta do serviço de pagamento por uso.

Perguntas e respostas

O LangChain pode usar uma API hospedada em vez de um modelo local?

Sim. ChatOpenAI aceita base_url personalizada, então qualquer endpoint compatível com OpenAI funciona. Defina base_url para https://api.llmproxyapi.com/v1 e o modelo para uncensored.

Isso é igual a rodar um modelo localmente?

Não. O modelo roda nos servidores do provedor, então os prompts viajam pela rede, embora não sejam usados para treinamento. Se os dados devem ficar na sua máquina, use um servidor local.

Funciona com embeddings do LangChain?

Não. Não há endpoint de embeddings. Use um modelo de embeddings separado para recuperação e esta API para geração de chat.

Como evitar erros 429 no LangChain?

Mantenha max_concurrency em 8 ou menos em uma chave completa, 2 em uma chave de teste e defina max_retries no cliente para que ele aguarde e tente novamente.

Sua chave está a um formulário de distância

Crie uma conta, copie a chave e altere a base URL. Essa é toda a configuração.

Obter chave de API