# Utiliser le RPC blockchain dans les agents LangChain avec BlockVectra

> Source: https://docs.blockvectra.com/fr/guides/langchain/

Un agent LangChain lit des données blockchain en direct grâce à un seul outil qui envoie du JSON-RPC en POST à `https://api.blockvectra.com/v1/eth_mainnet/public`. Ce point de terminaison ne nécessite ni API key ni inscription pour les méthodes de `public.methods` de chaque chaîne. Une clé ajoute les autres, et le forfait gratuit offre 30,000,000 CU par fenêtre de 30 jours. Vérifié le 2026-10-11.

```python
import httpx
from langchain.agents import create_agent
from langchain.tools import tool

RPC = "https://api.blockvectra.com/v1/eth_mainnet/public"

@tool
def eth_block_number() -> str:
    """Return the latest Ethereum mainnet block number as a hex string."""
    body = {"jsonrpc": "2.0", "id": 1, "method": "eth_blockNumber", "params": []}
    return httpx.post(RPC, json=body, timeout=10).json()["result"]

agent = create_agent("claude-sonnet-5", tools=[eth_block_number])
result = agent.invoke({"messages": [{"role": "user", "content": "What is the latest block?"}]})
print(result["messages"][-1].content)
```

Installez avec `pip install langchain httpx` ; la chaîne du modèle et la clé de son fournisseur suivent le [démarrage rapide de LangChain](https://docs.langchain.com/oss/python/langchain/quickstart). L'outil utilise le [décorateur `@tool`](https://docs.langchain.com/oss/python/langchain/tools) de LangChain et [`create_agent`](https://reference.langchain.com/python/langchain/agents/factory/create_agent).

## Le même outil en TypeScript

```typescript
import * as z from "zod";
import { createAgent, tool } from "langchain";

const ethBlockNumber = tool(
  async () => {
    const res = await fetch("https://api.blockvectra.com/v1/eth_mainnet/public", {
      method: "POST",
      headers: { "content-type": "application/json" },
      body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "eth_blockNumber", params: [] }),
    });
    return (await res.json()).result as string;
  },
  { name: "eth_block_number", description: "Latest Ethereum mainnet block number (hex).", schema: z.object({}) },
);

const agent = createAgent({ model: "claude-sonnet-5", tools: [ethBlockNumber] });
```

Consultez le [guide des outils](https://docs.langchain.com/oss/javascript/langchain/tools) de LangChain JS pour la signature de `tool()`.

## Appeler n'importe quelle méthode avec une API key

Les méthodes absentes de `public.methods`, comme `eth_getLogs`, nécessitent une clé. Lisez-la depuis l'environnement et envoyez-la dans l'en-tête `x-api-key` ; le slug de la chaîne (`eth_mainnet`, `base_mainnet`, etc.) provient de `GET /v1/chains` :

```python
import os
import httpx
from langchain.tools import tool

@tool
def rpc_call(chain: str, method: str, params: list) -> dict:
    """Call a JSON-RPC method on a BlockVectra chain slug such as base_mainnet."""
    headers = {"x-api-key": os.environ["BLOCKVECTRA_API_KEY"]}
    body = {"jsonrpc": "2.0", "id": 1, "method": method, "params": params}
    return httpx.post(f"https://api.blockvectra.com/v1/{chain}", json=body, headers=headers, timeout=15).json()
```

Renvoyer toute la réponse JSON-RPC permet au modèle de lire un objet `error` et de modifier son appel suivant. Pour créer la clé sans navigateur, suivez le flux en quatre étapes du [guide d'inscription programmatique](https://docs.blockvectra.com/fr/guides/programmatic-signup/?ref=docs-langchain) : challenge, signature, connexion, puis `POST /keys`. Les développeurs peuvent aussi [créer une clé dans la console](https://console.blockvectra.com/login/?next=%2Fkeys%2F\&ref=docs-langchain).

## Ajouter le serveur MCP de documentation

Les agents LangChain se connectent aux serveurs MCP via `MCPAdapter`. Pointez-le vers `https://docs.blockvectra.com/mcp` pour donner à l'agent `list_chains`, `get_status`, `rpc_call`, `read_doc` et les autres outils listés sur la [page du serveur MCP](https://docs.blockvectra.com/fr/guides/mcp-server/). La connexion ne nécessite aucune clé.

```python
from langchain.agents import create_agent
from langchain.mcp import MCPAdapter

async def main():
    async with MCPAdapter("https://docs.blockvectra.com/mcp") as adapter:
        tools = await adapter.list_tools()
        agent = create_agent("claude-sonnet-5", tools)
        return await agent.ainvoke({"messages": [{"role": "user", "content": "List the supported chains."}]})
```

Installez avec `pip install "langchain[mcp]"` (`langchain>=1.4.0`, en bêta). Pour utiliser les outils avec clé, transmettez la clé comme jeton bearer : `MCPAdapter(Client(url, auth=os.environ["BLOCKVECTRA_API_KEY"]))` avec `from fastmcp.client import Client`, comme dans le [guide d'authentification MCP](https://docs.langchain.com/oss/python/langchain/mcp/auth) de LangChain.

En TypeScript, installez `@langchain/mcp-adapters@^2.0.0` et transmettez une table d'en-têtes :

```typescript
import { MCPAdapter } from "@langchain/mcp-adapters";
import { createAgent } from "langchain";

const adapter = new MCPAdapter({
  servers: {
    blockvectra: {
      url: "https://docs.blockvectra.com/mcp",
      headers: { "x-api-key": process.env.BLOCKVECTRA_API_KEY! },
    },
  },
});

try {
  const agent = createAgent({ model: "claude-sonnet-5", tools: await adapter.listTools() });
  // agent.invoke(...)
} finally {
  await adapter.close();
}
```

Supprimez la ligne `headers` pour vous connecter sans clé. Références officielles : [LangChain MCP (Python)](https://docs.langchain.com/oss/python/langchain/mcp) et [LangChain MCP (JavaScript)](https://docs.langchain.com/oss/javascript/langchain/mcp).

## Erreurs que votre outil rencontrera

| Réponse                               | Signification                                               | Ce que l'agent doit faire                                                            |
| ------------------------------------- | ----------------------------------------------------------- | ------------------------------------------------------------------------------------ |
| HTTP 401, `-32024`, `missing_api_key` | URL avec clé appelée sans clé                               | Envoyer la clé dans `x-api-key` ou dans le chemin                                    |
| HTTP 401, `-32024`, `invalid_api_key` | Clé inconnue, désactivée ou révoquée                        | Vérifier la clé dans la console ; une nouvelle clé met quelques secondes à s'activer |
| `-32601`, `method_not_public`         | La méthode ne figure pas dans `public.methods` de la chaîne | Utiliser une URL avec clé au lieu de `/public`                                       |
| `-32601`, méthode non disponible      | La méthode n'est pas activée sur cette chaîne               | Vérifier `methods.allow` dans `GET /v1/chains`                                       |

Chaque erreur comporte `data.reason` et un `docs_url` ; la liste complète se trouve sur la [page des erreurs](https://docs.blockvectra.com/fr/errors/).

## Questions fréquentes

**Le point de terminaison public fonctionne-t-il pour `eth_getLogs` ?** Non. Il ne sert que les méthodes de `public.methods` de la chaîne ; `eth_getLogs` et la Data API nécessitent une API key.

**L'agent peut-il transmettre l'API key comme argument d'outil ?** Non. Conservez-la dans l'environnement ou dans les en-têtes du client MCP ; le serveur MCP rejette les clés placées dans les arguments d'outils.

**L'outil peut-il cibler une autre chaîne ?** Oui. Remplacez `eth_mainnet` par n'importe quel slug de chaîne disposant d'une `public.url` dans `GET /v1/chains`.

## Prochaines étapes

* [Vue d'ensemble des frameworks d'agents](https://docs.blockvectra.com/fr/guides/agent-frameworks/) pour ElizaOS, viem, wagmi et Coinbase AgentKit.
* [Connecter un agent IA](https://docs.blockvectra.com/fr/guides/ai-agents/) pour découvrir les points de terminaison avec MCP, llms.txt et OpenAPI.
* [Règles de facturation](https://docs.blockvectra.com/fr/guides/billing-rules/) pour la mesure en CU, les limites de débit et les erreurs non facturées.