# LangChain et LlamaIndex avec des modèles open-weight

> Utilisez des LLM open-weight dans LangChain et LlamaIndex : ChatOpenAI avec une base_url, le binding d'outils et OpenAILike. Payez au token en crypto.

- URL: https://llmwithcrypto.com/fr/docs/langchain/
- Dernière mise à jour: 2026-10-23
- Éditeur: LLMwithCrypto (https://llmwithcrypto.com)

LangChain et LlamaIndex fournissent tous deux un modèle de chat OpenAI qui accepte une base URL personnalisée. Pointez-le vers notre API et chaque chain, agent et retriever que vous avez construit continue de fonctionner, désormais exécuté sur DeepSeek, Qwen, gpt-oss et les autres modèles open-weight.

**Réponse rapide — Comment utiliser LLMwithCrypto dans LangChain ?**

Installez `langchain-openai` et créez `ChatOpenAI(model="deepseek-v4-pro", base_url="https://llmwithcrypto.com/api/v1", api_key=…)`. **LLMwithCrypto** parle le format de chat OpenAI, donc `invoke`, le streaming et `bind_tools` fonctionnent comme avec OpenAI, sur les modèles qui prennent en charge les outils. LlamaIndex utilise `OpenAILike` avec la même base URL. Documenté le 23 octobre 2026.

## Quelle classe utiliser

| Attribut | Valeur |
| --- | --- |
| LangChain (Python) | `ChatOpenAI` depuis `langchain-openai`, avec `base_url` |
| LangChain.js | `ChatOpenAI` depuis `@langchain/openai`, avec `configuration.baseURL` |
| LlamaIndex | `OpenAILike` depuis `llama-index-llms-openai-like`, avec `api_base` et `is_chat_model=True` |
| Ids de modèle | Sur la [page des modèles](https://llmwithcrypto.com/fr/models/) |

## Comment configurer ChatOpenAI ?

Passez l'URL de base et la clé au moment de créer le modèle. Définir `max_tokens` empêche chaque étape d'une chaîne ou d'un agent d'écrire plus que ce que vous voulez payer ; le `usage_metadata` de la réponse indique les tokens de chaque appel.

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

```

## Les tools et les agents fonctionnent-ils ?

Oui, sur les modèles qui prennent en charge le tool calling. Le streaming fonctionne sur tous les modèles ; le tool calling et la sortie JSON suivent ce que chaque modèle prend lui-même en charge. `bind_tools` envoie vos tools au format OpenAI ; testez votre schéma sur le modèle que vous choisissez avant d'en dépendre. Les agents LangGraph construits sur `ChatOpenAI` fonctionnent de la même manière.

*LangChain : un tool lié à 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"]))

```

## Et depuis JavaScript ?

LangChain.js prend l'URL de base dans `configuration`, qu'il transmet au client OpenAI sous-jacent.

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

```

## Comment l'utiliser dans LlamaIndex ?

Utilisez `OpenAILike`, qui ne vérifie pas les noms de modèles par rapport à la liste d'OpenAI. Définissez `is_chat_model=True` pour qu'il envoie des messages de chat, et indiquez la fenêtre de contexte du modèle pour que LlamaIndex puisse dimensionner ses prompts : DeepSeek V4.1 Flash lit jusqu'à 1M tokens au 23 octobre 2026, l'exemple définit volontairement une fenêtre plus petite pour garder des prompts courts.

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

```

## Comment garder les coûts d'un agent sous contrôle ?

Un agent appelle le modèle de nombreuses fois par tâche : une fois pour planifier, une fois par résultat de tool, une fois pour répondre. Chaque appel renvoie toute la conversation, donc l'entrée grossit à chaque étape.

- **Plafonnez chaque appel** avec `max_tokens`, et l'ensemble de l'exécution avec un nombre maximum d'étapes.
- **Utilisez un petit modèle quand cela suffit.** Au 23 octobre 2026, gpt-oss-20b coûte $0.033 par million de tokens en entrée contre $1.254 pour DeepSeek V4 Pro : envoyez les étapes simples au petit et gardez le grand pour la réponse finale.
- **Tronquez l'historique** dans les longues conversations, ou résumez les anciens tours.
- **Surveillez le crédit** avec `GET https://llmwithcrypto.com/api/v1/credits` avant les grosses exécutions.

Le dashboard liste chaque appel avec ses tokens et son coût, ce qui montre vite quelle étape d'une chaîne est la plus chère.

## Frameworks : questions fréquentes

### Puis-je mélanger plusieurs modèles dans une même chaîne ?

Oui : créez un `ChatOpenAI` par modèle, par exemple un modèle bon marché pour le routage et un grand pour la réponse finale. Tous dépensent le même crédit.

### Les embeddings fonctionnent-ils ?

Non. L'API sert uniquement des chat completions ; utilisez votre modèle d'embedding existant en parallèle.

### Que payé-je pour une exécution d'agent ?

Chaque appel au modèle de l'exécution, au token. Vous payez au token depuis votre solde : les tokens d'entrée et de sortie sont comptés par le tokenizer du modèle lui-même et facturés au prix de ce modèle par 1M de tokens. Un appel qui se termine par une erreur ne coûte rien. Les prix par modèle figurent sur la [page des tarifs](https://llmwithcrypto.com/fr/pricing/).

---

LLMwithCrypto: LLMwithCrypto est une API LLM compatible OpenAI pour les modèles open-weight — 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 — facturés au token depuis un solde crypto prépayé, à 5 % en dessous du prix médian des hébergeurs publics. Sans KYC : pas de pièce d'identité, pas de selfie, pas de documents. Les prompts et les sorties ne sont pas stockés.