# LangChain y LlamaIndex con modelos open-weight

> Usa LLM open-weight en LangChain y LlamaIndex: ChatOpenAI con base_url, binding de herramientas, LangChain.js y OpenAILike. Paga por token con criptomonedas.

- URL: https://llmwithcrypto.com/es/docs/langchain/
- Última actualización: 2026-10-23
- Editor: LLMwithCrypto (https://llmwithcrypto.com)

LangChain y LlamaIndex incluyen un modelo de chat de OpenAI que acepta una base URL personalizada. Apúntalo a nuestra API y cada cadena, agente y retriever que hayas construido sigue funcionando, ahora sobre DeepSeek, Qwen, gpt-oss y los demás modelos open-weight.

**Respuesta rápida — ¿Cómo uso LLMwithCrypto en LangChain?**

Instala `langchain-openai` y crea `ChatOpenAI(model="deepseek-v4-pro", base_url="https://llmwithcrypto.com/api/v1", api_key=…)`. **LLMwithCrypto** habla el formato de chat de OpenAI, así que `invoke`, el streaming y `bind_tools` funcionan como con OpenAI, en los modelos que soportan herramientas. LlamaIndex usa `OpenAILike` con la misma base URL. Documentado el 23 de octubre de 2026.

## Qué clase usar

| Atributo | Valor |
| --- | --- |
| LangChain (Python) | `ChatOpenAI` desde `langchain-openai`, con `base_url` |
| LangChain.js | `ChatOpenAI` desde `@langchain/openai`, con `configuration.baseURL` |
| LlamaIndex | `OpenAILike` desde `llama-index-llms-openai-like`, con `api_base` y `is_chat_model=True` |
| Ids de modelos | En la [página de modelos](https://llmwithcrypto.com/es/models/) |

## ¿Cómo configuro ChatOpenAI?

Pasa la base URL y la clave al crear el modelo. Configurar `max_tokens` evita que cada paso de una cadena o de un agente escriba más de lo que quieres pagar; el `usage_metadata` de la respuesta muestra los tokens de cada llamada.

*LangChain: ChatOpenAI en DeepSeek V4 Pro*

```python
import os

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="deepseek-v4-pro",
    base_url="https://llmwithcrypto.com/api/v1",
    api_key=os.environ["LLMWITHCRYPTO_API_KEY"],
    max_tokens=300,
    temperature=0.3,
)
reply = llm.invoke("Explain what a vector database is in two sentences.")
print(reply.content)
print(reply.usage_metadata)

```

## ¿Funcionan las tools y los agentes?

Sí, en los modelos que admiten tool calling. El streaming funciona en todos los modelos; el tool calling y la salida JSON dependen de lo que admita cada modelo. `bind_tools` envía tus tools en el formato de OpenAI; prueba tu schema en el modelo que elijas antes de depender de él. Los agentes de LangGraph construidos sobre `ChatOpenAI` funcionan igual.

*LangChain: una tool vinculada a gpt-oss-120b*

```python
import os

from langchain_core.tools import tool
from langchain_openai import ChatOpenAI


@tool
def convert_currency(amount: float, rate: float) -> float:
    """Convert an amount with an exchange rate."""
    return round(amount * rate, 2)


llm = ChatOpenAI(
    model="gpt-oss-120b",
    base_url="https://llmwithcrypto.com/api/v1",
    api_key=os.environ["LLMWITHCRYPTO_API_KEY"],
)
llm_with_tools = llm.bind_tools([convert_currency])
msg = llm_with_tools.invoke("How much is 250 at a rate of 0.92?")
for call in msg.tool_calls:
    print(call["name"], call["args"], "->", convert_currency.invoke(call["args"]))

```

## ¿Y desde JavaScript?

LangChain.js recibe la base URL dentro de `configuration`, que pasa al cliente de OpenAI subyacente.

*LangChain.js: ChatOpenAI con una baseURL*

```javascript
import { ChatOpenAI } from '@langchain/openai';

const llm = new ChatOpenAI({
  model: 'qwen3-235b-a22b-instruct-2507',
  apiKey: process.env.LLMWITHCRYPTO_API_KEY,
  configuration: { baseURL: 'https://llmwithcrypto.com/api/v1' },
  maxTokens: 300,
});
const reply = await llm.invoke('Give me a three-step plan to learn SQL.');
console.log(reply.content);

```

## ¿Cómo lo uso en LlamaIndex?

Usa `OpenAILike`, que no comprueba los nombres de los modelos contra la lista de OpenAI. Configura `is_chat_model=True` para que envíe mensajes de chat y dale la ventana de contexto del modelo para que LlamaIndex pueda dimensionar sus prompts: DeepSeek V4.1 Flash lee hasta 1M tokens a fecha de 23 de octubre de 2026; el ejemplo configura una ventana más pequeña a propósito para mantener los prompts cortos.

*LlamaIndex: OpenAILike en DeepSeek V4.1 Flash*

```python
import os

from llama_index.llms.openai_like import OpenAILike

llm = OpenAILike(
    model="deepseek-v4.1-flash",
    api_base="https://llmwithcrypto.com/api/v1",
    api_key=os.environ["LLMWITHCRYPTO_API_KEY"],
    is_chat_model=True,
    context_window=131072,
    max_tokens=300,
)
print(llm.complete("Name three uses of a knowledge graph."))

```

## ¿Cómo mantengo bajo control los costes de los agentes?

Un agente llama al modelo muchas veces por tarea: una para planificar, una por cada resultado de tool y una para responder. Cada llamada reenvía toda la conversación, así que la entrada crece en cada paso.

- **Limita cada llamada** con `max_tokens`, y toda la ejecución con un número máximo de pasos.
- **Usa un modelo pequeño donde sea suficiente.** A fecha de 23 de octubre de 2026, gpt-oss-20b cuesta $0.033 por millón de tokens de entrada frente a $1.254 de DeepSeek V4 Pro: dirige los pasos simples al pequeño y reserva el grande para la respuesta final.
- **Recorta el historial** en conversaciones largas, o resume los turnos antiguos.
- **Vigila el saldo** con `GET https://llmwithcrypto.com/api/v1/credits` antes de ejecuciones grandes.

El panel lista cada llamada con sus tokens y su coste, lo que muestra rápido qué paso de una cadena es el caro.

## Frameworks: preguntas frecuentes

### ¿Puedo mezclar modelos en una misma cadena?

Sí: crea un `ChatOpenAI` por modelo, por ejemplo uno barato para el enrutamiento y uno grande para la respuesta final. Todos gastan el mismo saldo.

### ¿Funcionan los embeddings?

No. La API solo sirve chat completions; usa tu modelo de embeddings actual junto a ella.

### ¿Qué pago por una ejecución de un agente?

Cada llamada al modelo de la ejecución, por token. Pagas por token desde tu saldo: los tokens de entrada y de salida se cuentan con el tokenizador propio del modelo y se cobran al precio de ese modelo por 1M de tokens. Una llamada que termina en error no cuesta nada. Los precios por modelo están en la [página de precios](https://llmwithcrypto.com/es/pricing/).

---

LLMwithCrypto: LLMwithCrypto es una API de LLM compatible con OpenAI para modelos de pesos abiertos — DeepSeek V4 Pro, DeepSeek V4.1 Flash, DeepSeek R1, Qwen3.5 397B A17B, Qwen3 235B A22B Instruct, gpt-oss-120b, gpt-oss-20b, GLM-4.7, Llama 3.3 70B Instruct, Gemma 4 31B, Mistral Large 3, Mistral Small 4 — con pago por token desde un saldo de criptomonedas prepago, a un 5% por debajo del precio medio de los hosts públicos. Sin KYC: sin identificación, sin selfie, sin documentos. Los prompts y las salidas no se almacenan.