# Intégrations DimaRouter

Utilisez les modèles DimaRouter dans vos outils et agents. Partout : base URL `https://api.dimarouter.ma/v1`, clé `DIMA_API_KEY`, serveur MCP `https://api.dimarouter.ma/mcp`.

## Claude Code

Claude Code parle à DimaRouter par la route compatible Anthropic Messages, et peut utiliser le serveur MCP pour le solde, la consommation, les clés et le paiement.

**Terminal**

```bash
export ANTHROPIC_BASE_URL="https://api.dimarouter.ma"
export ANTHROPIC_AUTH_TOKEN="$DIMA_API_KEY"
export ANTHROPIC_MODEL="zai-org/GLM-5.3-Flash"
export ANTHROPIC_DEFAULT_HAIKU_MODEL="zai-org/GLM-5.3-Flash"

# Serveur MCP : solde, consommation, clés et paiement depuis Claude Code
claude mcp add --transport http dimarouter https://api.dimarouter.ma/mcp \
  --header "Authorization: Bearer $DIMA_API_KEY"
claude
```

## Claude Desktop et claude.ai

Ajoutez DimaRouter comme connecteur personnalisé.

1. Réglages → Connecteurs → Ajouter un connecteur personnalisé, URL : https://api.dimarouter.ma/mcp.
2. Sans en-tête d’authentification, seuls les outils publics sont disponibles : list_models, get_docs, create_account.
3. Pour les outils du compte (chat, solde, clés, paiement), utilisez Claude Code ou un client MCP qui envoie l’en-tête Authorization.



## Codex

Codex utilise la route compatible OpenAI Responses (streaming, shell, apply_patch) et le serveur MCP.

**~/.codex/config.toml**

```toml
model = "zai-org/GLM-5.3-Flash"
model_provider = "dimarouter"

[model_providers.dimarouter]
name = "DimaRouter"
base_url = "https://api.dimarouter.ma/v1"
env_key = "DIMA_API_KEY"
wire_api = "responses"
requires_openai_auth = false

[mcp_servers.dimarouter]
url = "https://api.dimarouter.ma/mcp"
bearer_token_env_var = "DIMA_API_KEY"
```

## Cursor

Modèles DimaRouter dans le chat de Cursor, et outils du compte par MCP.

1. Cursor Settings → Models → OpenAI API Key : collez votre clé DimaRouter, activez « Override OpenAI Base URL » avec https://api.dimarouter.ma/v1.
2. Ajoutez un modèle personnalisé avec l’ID zai-org/GLM-5.3-Flash (ou tout autre ID du catalogue).
3. Pour le MCP, créez .cursor/mcp.json (ci-dessous) et exportez DIMA_API_KEY.

**.cursor/mcp.json**

```json
{
  "mcpServers": {
    "dimarouter": {
      "url": "https://api.dimarouter.ma/mcp",
      "headers": { "Authorization": "Bearer ${env:DIMA_API_KEY}" }
    }
  }
}
```

## Kimi Code

Kimi Code accepte DimaRouter comme fournisseur compatible OpenAI.

1. Ajoutez le fournisseur et le modèle dans ~/.kimi-code/config.toml (ci-dessous), puis exportez DIMA_API_KEY.
2. Pour le MCP, ajoutez dans ~/.kimi-code/mcp.json : {"mcpServers": {"dimarouter": {"url": "https://api.dimarouter.ma/mcp", "bearerTokenEnvVar": "DIMA_API_KEY"}}}.

**~/.kimi-code/config.toml**

```toml
[providers.dimarouter]
type = "openai"
base_url = "https://api.dimarouter.ma/v1"
api_key_env = "DIMA_API_KEY"

[models."glm-5.3-flash"]
provider = "dimarouter"
model = "zai-org/GLM-5.3-Flash"
max_context_size = 200000
```

## DeepSeek Harness (dsh)

DeepSeek Harness accepte tout point d’entrée compatible OpenAI comme fournisseur personnalisé.

1. Ouvrez dsh, puis Settings → Models → Add custom provider.
2. Renseignez les valeurs ci-dessous et choisissez un modèle du catalogue.

**Settings → Models → Custom provider**

```toml
Provider id = dimarouter
Base URL    = https://api.dimarouter.ma/v1
Protocol    = OpenAI Chat Completions
API key     = <votre clé DIMA_API_KEY>
Model       = deepseek-ai/DeepSeek-V4.1-Flash-1017
```

## OpenAI SDK et Agents SDK

Tous les SDK OpenAI fonctionnent en changeant la base URL (https://api.dimarouter.ma/v1). Avec l’Agents SDK, ajoutez le serveur MCP DimaRouter comme outil.

**agent.py**

```python
import asyncio, os
from openai import AsyncOpenAI
from agents import Agent, Runner, OpenAIChatCompletionsModel, set_tracing_disabled
from agents.mcp import MCPServerStreamableHttp

key = os.environ["DIMA_API_KEY"]
client = AsyncOpenAI(base_url="https://api.dimarouter.ma/v1", api_key=key)
set_tracing_disabled(True)

async def main():
    async with MCPServerStreamableHttp(
        name="dimarouter",
        params={"url": "https://api.dimarouter.ma/mcp", "headers": {"Authorization": f"Bearer {key}"}},
    ) as dimarouter:
        agent = Agent(
            name="Assistant",
            instructions="Réponds en français.",
            model=OpenAIChatCompletionsModel(model="zai-org/GLM-5.3-Flash", openai_client=client),
            mcp_servers=[dimarouter],
        )
        result = await Runner.run(agent, "Quel est mon solde DimaRouter ?")
        print(result.final_output)

asyncio.run(main())
```

## OpenCode

OpenCode utilise DimaRouter comme fournisseur compatible OpenAI.

**opencode.json**

```json
{
  "$schema": "https://opencode.ai/config.json",
  "providers": {
    "dimarouter": {
      "name": "DimaRouter",
      "env": ["DIMA_API_KEY"],
      "package": "@opencode/ai/providers/openai-compatible",
      "settings": {
        "baseURL": "https://api.dimarouter.ma/v1"
      },
      "models": {
        "zai-org/GLM-5.3-Flash": { "name": "GLM 5.3 Flash" }
      }
    }
  }
}
```

## Migrer depuis OpenRouter

Le SDK OpenRouter fonctionne avec DimaRouter en changeant l’URL du serveur et la clé.

**app.ts**

```ts
import { HTTPClient, OpenRouter } from "@openrouter/sdk"

const httpClient = new HTTPClient({
  fetcher: async (request, init) => {
    const response = await fetch(request, init)
    if (!response.ok) return response
    const data = await response.json()
    return Response.json({
      ...data,
      system_fingerprint: data.system_fingerprint ?? null,
    }, { status: response.status })
  },
})

const client = new OpenRouter({
  serverURL: "https://api.dimarouter.ma/v1",
  apiKey: process.env.DIMA_API_KEY ?? "",
  httpClient,
})

const response = await client.chat.send({
  chatRequest: {
    model: "zai-org/GLM-5.3-Flash",
    messages: [{ role: "user", content: "Salam" }],
    stream: false,
  },
})
console.log(response.choices[0]?.message?.content)
```
