# LangChain en LlamaIndex met open-weight modellen

> Gebruik open-weight LLMs in LangChain en LlamaIndex: ChatOpenAI met een base_url, tool binding, LangChain.js en OpenAILike. Betaal per token met crypto.

- URL: https://llmwithcrypto.com/nl/docs/langchain/
- Laatst bijgewerkt: 2026-10-23
- Uitgever: LLMwithCrypto (https://llmwithcrypto.com)

LangChain en LlamaIndex leveren allebei een OpenAI-chatmodel dat een aangepaste base URL accepteert. Richt het op onze API en elke chain, agent en retriever die je hebt gebouwd blijft werken, nu op DeepSeek, Qwen, gpt-oss en de andere open-weight modellen.

**Snel antwoord — Hoe gebruik ik LLMwithCrypto in LangChain?**

Installeer `langchain-openai` en maak `ChatOpenAI(model="deepseek-v4-pro", base_url="https://llmwithcrypto.com/api/v1", api_key=…)`. **LLMwithCrypto** spreekt het OpenAI-chatformaat, dus `invoke`, streaming en `bind_tools` werken zoals bij OpenAI, op de modellen die tools ondersteunen. LlamaIndex gebruikt `OpenAILike` met dezelfde base URL. Gedocumenteerd op 23 oktober 2026.

## Welke class je moet gebruiken

| Eigenschap | Waarde |
| --- | --- |
| LangChain (Python) | `ChatOpenAI` van `langchain-openai`, met `base_url` |
| LangChain.js | `ChatOpenAI` van `@langchain/openai`, met `configuration.baseURL` |
| LlamaIndex | `OpenAILike` van `llama-index-llms-openai-like`, met `api_base` en `is_chat_model=True` |
| Model-ids | Op de [modellenpagina](https://llmwithcrypto.com/nl/models/) |

## Hoe stel ik ChatOpenAI in?

Geef de base URL en de API-sleutel mee wanneer je het model aanmaakt. Met `max_tokens` zorg je dat geen enkele stap in een chain of agent meer schrijft dan je wilt betalen; de `usage_metadata` van het antwoord toont de tokens van elke call.

*LangChain: ChatOpenAI op 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)

```

## Werken tools en agents?

Ja, op de modellen die tool calling ondersteunen. Streaming werkt op elk model; tool calling en JSON-output volgen wat elk model zelf ondersteunt. `bind_tools` stuurt je tools in het OpenAI-formaat; test je schema op het model dat je kiest voordat je erop vertrouwt. LangGraph-agents die op `ChatOpenAI` zijn gebouwd, werken op dezelfde manier.

*LangChain: een tool gekoppeld aan 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"]))

```

## En vanuit JavaScript?

LangChain.js neemt de base URL op in `configuration`, die het doorgeeft aan de onderliggende OpenAI-client.

*LangChain.js: ChatOpenAI met een 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);

```

## Hoe gebruik ik het in LlamaIndex?

Gebruik `OpenAILike`, dat modelnamen niet tegen OpenAI's lijst controleert. Zet `is_chat_model=True` zodat het chatberichten verstuurt, en geef het contextvenster van het model mee zodat LlamaIndex zijn prompts kan afmeten: DeepSeek V4.1 Flash leest per 23 oktober 2026 tot 1M tokens, het voorbeeld zet met opzet een kleiner venster om prompts kort te houden.

*LlamaIndex: OpenAILike op 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."))

```

## Hoe houd ik de kosten van een agent onder controle?

Een agent roept het model vele malen per taak aan: één keer om te plannen, één keer per toolresultaat, één keer om te antwoorden. Elke call stuurt het hele gesprek opnieuw mee, dus de input groeit bij elke stap.

- **Beperk elke call** met `max_tokens`, en de hele run met een maximum aantal stappen.
- **Gebruik een klein model waar het volstaat.** Per 23 oktober 2026 kost gpt-oss-20b $0.033 per miljoen inputtokens tegenover $1.254 voor DeepSeek V4 Pro: stuur eenvoudige stappen naar het kleine model en houd het grote voor het uiteindelijke antwoord.
- **Dun de geschiedenis uit** in lange gesprekken, of vat oude beurten samen.
- **Let op je credits** met `GET https://llmwithcrypto.com/api/v1/credits` vóór grote runs.

Het dashboard toont elke call met de tokens en de kosten, zodat je snel ziet welke stap van een chain duur is.

## Frameworks: veelgestelde vragen

### Kan ik modellen combineren in één chain?

Ja: maak één `ChatOpenAI` per model, bijvoorbeeld een goedkoop model voor routing en een groot model voor het uiteindelijke antwoord. Ze gebruiken allemaal dezelfde credits.

### Werken embeddings?

Nee. De API levert alleen chat completions; gebruik je bestaande embeddingmodel ernaast.

### Wat betaal ik voor een agent-run?

Elke modelcall van de run, per token. Je betaalt per token vanaf je saldo: input- en outputtokens worden geteld door de tokenizer van het model zelf en afgerekend tegen de prijs van dat model per 1M tokens. Een call die op een fout eindigt, kost niets. Prijzen per model staan op de [prijzenpagina](https://llmwithcrypto.com/nl/pricing/).

---

LLMwithCrypto: LLMwithCrypto is een OpenAI-compatibele LLM API voor open-weight modellen — 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 — betaald per token vanaf een prepaid crypto-saldo, tegen 5% onder de mediane prijs van de publieke hosts. Zonder KYC: geen ID, geen selfie, geen documenten. Prompts en outputs worden niet opgeslagen.