# LangChain e LlamaIndex con modelli open-weight

> Usa LLM open-weight in LangChain e LlamaIndex: ChatOpenAI con un base_url, tool binding, LangChain.js e OpenAILike. Paga per token in criptovalute.

- URL: https://llmwithcrypto.com/it/docs/langchain/
- Ultimo aggiornamento: 2026-10-23
- Editore: LLMwithCrypto (https://llmwithcrypto.com)

LangChain e LlamaIndex includono entrambi un chat model OpenAI che accetta un base URL personalizzato. Puntalo sulla nostra API e ogni chain, agent e retriever che hai costruito continua a funzionare, ora in esecuzione su DeepSeek, Qwen, gpt-oss e gli altri modelli open-weight.

**Risposta rapida — Come uso LLMwithCrypto in LangChain?**

Installa `langchain-openai` e crea `ChatOpenAI(model="deepseek-v4-pro", base_url="https://llmwithcrypto.com/api/v1", api_key=…)`. **LLMwithCrypto** parla il formato chat OpenAI, quindi `invoke`, lo streaming e `bind_tools` funzionano come con OpenAI, sui modelli che supportano i tool. LlamaIndex usa `OpenAILike` con lo stesso base URL. Documentato il 23 ottobre 2026.

## Quale classe usare

| Attributo | Valore |
| --- | --- |
| LangChain (Python) | `ChatOpenAI` da `langchain-openai`, con `base_url` |
| LangChain.js | `ChatOpenAI` da `@langchain/openai`, con `configuration.baseURL` |
| LlamaIndex | `OpenAILike` da `llama-index-llms-openai-like`, con `api_base` e `is_chat_model=True` |
| Id dei modelli | Sulla [pagina dei modelli](https://llmwithcrypto.com/it/models/) |

## Come configuro ChatOpenAI?

Passa il base URL e la chiave quando crei il modello. Impostare `max_tokens` impedisce che ogni passo di una chain o di un agent scriva più di quanto vuoi pagare; il `usage_metadata` della risposta mostra i token di ogni chiamata.

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

```

## Tool e agent funzionano?

Sì, sui modelli che supportano il tool calling. Lo streaming funziona su ogni modello; il tool calling e l'output JSON seguono ciò che supporta il singolo modello. `bind_tools` invia i tuoi tool nel formato OpenAI; testa il tuo schema sul modello che scegli prima di affidarti a lui. Gli agent LangGraph costruiti su `ChatOpenAI` funzionano allo stesso modo.

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

```

## E da JavaScript?

LangChain.js prende il base URL dentro `configuration`, che passa al client OpenAI sottostante.

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

```

## Come lo uso in LlamaIndex?

Usa `OpenAILike`, che non confronta i nomi dei modelli con la lista di OpenAI. Imposta `is_chat_model=True` così invia messaggi chat, e fornisci la context window del modello così LlamaIndex può dimensionare i suoi prompt: DeepSeek V4.1 Flash legge fino a 1M token al 23 ottobre 2026, l'esempio imposta di proposito una finestra più piccola per tenere i prompt brevi.

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

```

## Come tengo sotto controllo i costi degli agent?

Un agent chiama il modello molte volte per attività: una per pianificare, una per ogni risultato di un tool, una per rispondere. Ogni chiamata rinvia tutta la conversazione, quindi l'input cresce a ogni passo.

- **Limita ogni chiamata** con `max_tokens`, e l'intera esecuzione con un numero massimo di passi.
- **Usa un modello piccolo dove basta.** Al 23 ottobre 2026, gpt-oss-20b costa $0.033 per milione di token di input contro $1.254 di DeepSeek V4 Pro: manda i passi semplici al piccolo e tieni il grande per la risposta finale.
- **Riduci la cronologia** nelle conversazioni lunghe, o riassumi i turni vecchi.
- **Tieni d'occhio i crediti** con `GET https://llmwithcrypto.com/api/v1/credits` prima delle esecuzioni grandi.

La dashboard elenca ogni chiamata con i suoi token e il suo costo, il che mostra subito quale passo di una chain è quello costoso.

## Framework: domande frequenti

### Posso mescolare modelli in una chain?

Sì: crea un `ChatOpenAI` per modello, per esempio uno economico per il routing e uno grande per la risposta finale. Tutti spendono gli stessi crediti.

### Gli embedding funzionano?

No. L'API serve solo chat completion; usa il tuo modello di embedding esistente insieme a essa.

### Quanto pago per l'esecuzione di un agent?

Ogni chiamata al modello dell'esecuzione, per token. Paghi per token dal tuo saldo: i token di input e di output vengono contati dal tokenizer del modello stesso e addebitati al prezzo di quel modello per 1M di token. Una chiamata che termina con un errore non costa nulla. I prezzi per modello sono sulla [pagina dei prezzi](https://llmwithcrypto.com/it/pricing/).

---

LLMwithCrypto: LLMwithCrypto è un'API LLM compatibile con OpenAI per modelli 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 — pagati a token da un saldo prepagato in criptovalute, al 5% sotto il prezzo mediano degli host pubblici. Senza KYC: niente documento, niente selfie, niente documenti. I prompt e gli output non vengono memorizzati.