Local o alojado: elige según la restricción que más te afecte
Las personas que buscan LangChain con un modelo local generalmente quieren una de tres cosas: privacidad, no pagar por token o independencia de un proveedor. Un modelo en tu propia máquina, servido por una herramienta como Ollama o llama.cpp, ofrece las tres si tienes hardware que pueda ejecutarlo a una velocidad utilizable. La compensación es el tiempo de configuración, los límites de memoria y la velocidad de la GPU o CPU que tengas.
Un endpoint alojado intercambia eso por un pequeño costo de uso. Envías prompts por la red y el modelo se ejecuta en el hardware de otra persona. Aquí significa un modelo de pesos abiertos, ajustado para responder sin rechazos de contenido para uso adulto legal, servido a través de una API compatible con OpenAI. Los prompts no se usan para el entrenamiento, pero sí salen de tu máquina, por lo que un servicio alojado es la respuesta incorrecta si tu regla es que los datos nunca deben salir de ella.
La parte útil para un desarrollador de LangChain es que el código apenas difiere. Los servidores locales como Ollama y llama.cpp exponen endpoints estilo OpenAI, y un endpoint alojado habla el mismo protocolo. Si escribes tu aplicación contra ChatOpenAI con una base URL configurable, puedes desarrollar localmente y cambiar a un modelo alojado con una variable de entorno. Eso te da un híbrido práctico: itera con un modelo local pequeño y usa el alojado cuando quieras el comportamiento de un modelo más grande sin poseer la GPU.
Conecta ChatOpenAI al endpoint
Instala el paquete de integración y luego crea el objeto del modelo con las tres configuraciones importantes.
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)
Si esto se ejecuta, todo lo demás funciona de la misma manera. Obtén tu clave desde la página de clave de API; los nuevos usuarios pueden reclamar $0.50 de crédito de prueba con un solo clic allí después de registrarse, sin necesidad de tarjeta. Pasa la base URL explícitamente en el código en lugar de depender de una variable de entorno, porque diferentes versiones de la biblioteca leen diferentes nombres de variables y un fallback silencioso al host predeterminado de OpenAI enviaría tu clave al lugar equivocado.
El nombre del modelo es el único lugar donde la gente tropieza. El único ID aquí es uncensored. Un nombre como llama3 o gpt-4o no será reconocido.
Una cadena con una plantilla de prompt
La canalización estándar de prompt, modelo y analizador de salida se ejecuta sin cambios. Este ejemplo resume texto en un tono elegido.
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 muchas entradas, usa batch y limita la concurrencia. Una clave completa permite 8 peticiones simultáneas y 300 peticiones por minuto, así que mantén la configuración en 8 o menos:
results = chain.batch(
[{"tone": "dry", "text": t} for t in documents],
config={"max_concurrency": 6},
)
Una clave de prueba solo permite 2 peticiones simultáneas y 60 por minuto, así que usa max_concurrency de 2 mientras pruebas.
Streaming
La API transmite sobre Server-Sent Events, y LangChain expone esto a través de stream. Úsalo para interfaces de chat donde una persona observa cómo se forma la respuesta.
for chunk in llm.stream("Write a short scene set in a lighthouse."):
print(chunk.content, end="", flush=True)
Un detalle práctico: una petición transmitida mantiene su espacio de concurrencia hasta que termina la transmisión. Si tu interfaz abandona una transmisión a mitad de camino, asegúrate de que el generador se cierre, o tu capacidad de concurrencia se reducirá. El código asíncrono usa astream de la misma manera.
Herramientas y agentes
Las llamadas a herramientas son compatibles: la API acepta tools y tool_choice, transmite tool_calls y toma resultados de vuelta como mensajes role: "tool". LangChain envuelve esto en 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)
La lista de resultados muestra las llamadas que el modelo desea, con nombres y argumentos. Ejecútalas, añade los resultados como mensajes de herramienta y llama al modelo nuevamente, o deja que un marco de agente como LangGraph ejecute ese bucle. Los agentes hacen muchas llamadas por solicitud de usuario, por lo que alcanzan el límite por minuto más rápido que las cadenas simples. Cuenta las llamadas por ejecución antes de elegir un nivel de concurrencia.
La ventana de contexto es de 100,000 tokens para el prompt más el completado, lo cual es generoso para la memoria de la conversación. Aun así, recorta los turnos antiguos: pagas por todo el historial en cada llamada a $0.15 por cada 1M de tokens de entrada.
Salida JSON
El modo JSON está disponible a través de response_format. En LangChain puedes pasarlo con model_kwargs o usar el asistente de salida estructurada en modo JSON, y describir los campos en tu 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)
Con method="json_mode" el prompt debe indicarle al modelo qué claves producir; la clase Pydantic luego valida el resultado analizado. Mantén un reintento alrededor para la rara respuesta malformada.
Qué no se conserva
Dos elementos básicos de LangChain necesitan una fuente diferente. La API no tiene un endpoint de embeddings, por lo que OpenAIEmbeddings apuntado aquí fallará. Para la recuperación sobre tus documentos, usa un modelo de embeddings local u otro proveedor de embeddings, y usa este endpoint solo para el paso de chat. Tampoco tiene entrada de imagen ni generación, ni audio ni fine-tuning, por lo que las cadenas de visión y los cargadores multimodales quedan fuera.
El manejo de errores se trata principalmente de respuestas 429. El código rate_limited significa que excediste el límite por minuto, concurrency significa demasiadas llamadas paralelas, y un 429 con Retry-After: 5 marca sobrecarga temporal. Configura max_retries en ChatOpenAI para que el cliente espere y reintente. Las peticiones fallidas y rechazadas no se cobran.
Los encabezados de respuesta ayudan con la monitorización: X-Balance-USD muestra tu crédito restante y X-Request-Id identifica una llamada para soporte.
Cambiar entre local y alojado con una variable
Si quieres la configuración híbrida, pon las tres configuraciones en variables de entorno y construye el modelo en una función. Tus cadenas importan esa función y nunca mencionan un proveedor.
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"],
)
La rama local asume un servidor Ollama en su puerto predeterminado, que expone una ruta estilo OpenAI bajo /v1; consulta la documentación de tu propio servidor para la dirección y el nombre del modelo correctos. El comportamiento variará entre modelos, así que vuelve a ejecutar tus prompts después de un cambio. Un prompt ajustado para los hábitos de un modelo puede leerse de manera diferente en otro, y la calidad de las llamadas a herramientas varía según el modelo, así que prueba esas rutas primero.
Un flujo de trabajo sensato es desarrollar prompts contra el modelo alojado mientras no tienes una GPU libre, luego decidir qué partes de la aplicación deben permanecer en tu propia máquina. Los documentos sensibles pueden usar la rama local, y las características creativas públicas pueden usar la alojada.
Costo y próximos pasos
Los precios son $0.15 por cada 1M de tokens de entrada y $0.50 por cada 1M de tokens de salida, descontados del crédito prepago sin suscripción. Una llamada en cadena con 2,000 tokens de entrada y 500 de salida cuesta 2,000 x $0.15 / 1M + 500 x $0.50 / 1M = $0.0003 + $0.00025 = $0.00055. Mil llamadas de este tipo cuestan $0.55. Las recargas van de $20 a $500 con cripto (USDT en TRC20, USDC en Base), con un bono del 5% desde $50, 10% desde $100 y 15% desde $200. Los detalles están en la página de precios.
Para una vista de la misma API por HTTP simple, lee la guía de inicio rápido. El sitio también tiene un breve resumen del servicio de pago por uso.
