Documentation de l'API Shannon AI

Aperçu

Documents publics

Tout ce dont vous avez besoin pour être livré avec l'API compatible OpenAI et Anthropic de Shannon.

URL de base Compatible OpenAI

https://api.shannon-ai.com/v1/chat/completions

Utilisez l'API Chat Completions avec les appels de fonctions et le streaming.

URL de base Compatible anthropique

https://api.shannon-ai.com/v1/messages

Format Claude Messages avec outils et en-tête de version anthropique.

En-têtes Authentification

Autorisation : Porteur <votre-clé>

Ou X-API-Key avec version anthropique pour les appels de style Claude.

Accès Statut

Documents publics – Clé requise pour appeler

Streaming, appels de fonctions, sorties structurées, recherche sur le Web.

Liste de contrôle de lancement

+

Dirigez votre SDK vers Shannon

Définissez baseURL sur les points de terminaison OpenAI ou Anthropic ci-dessus.

Configuration
+

Joindre votre clé API

Utilisez les jetons Bearer pour les appels OpenAI ou X-API-Key + version anthropique.

Sécurité
+

Activer les outils et les sorties structurées

Prend en charge les outils/fonctions OpenAI, le schéma JSON et la recherche Web intégrée.

Capacités
+

Suivre l'utilisation

Affichez la consommation de jetons et de recherche sur cette page lorsque vous êtes connecté à votre compte.

Analyse

Capacités

OpenAI + Anthropique

Remplacement immédiat des API OpenAI et Anthropic avec prise en charge native des outils, des sorties structurées et de la recherche Web intégrée.

Remplacement instantané

Compatible

Fonctionne avec les SDK OpenAI et Anthropic. Changez simplement l'URL de base.

Appel de fonction

Outils

Définissez les outils, laissez Shannon les appeler. Prend en charge les modes automatique, forcé et aucun.

Recherche Web intégrée

Rechercher

Recherche Web en temps réel avec citations de sources. Disponible automatiquement.

Résultats structurés

JSON

Mode JSON et application du schéma JSON pour une extraction de données fiable.

Outils multi-tours

Agentique

Boucles d’exécution automatique des fonctions. Jusqu'à 10 itérations par requête.

Diffusion en continu

Rapide

Événements envoyés par le serveur pour le streaming de jetons en temps réel.

Démarrage rapide

5 minutes

Commencez en trois étapes. Shannon reflète les clients OpenAI et Anthropic.

Définissez votre URL de base

Utilisez le point de terminaison compatible OpenAI.

https://api.shannon-ai.com/v1/chat/completions

Ajoutez votre clé API

Utilisez l'authentification du porteur dans l'en-tête Autorisation.

Envoyez votre premier message

Choisissez une langue et échangez votre clé.

Python

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.shannon-ai.com/v1"
)

response = client.chat.completions.create(
    model="shannon-1.6-lite",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Hello, Shannon!"}
    ],
    max_tokens=1024
)

print(response.choices[0].message.content)

JavaScript

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'YOUR_API_KEY',
  baseURL: 'https://api.shannon-ai.com/v1'
});

const response = await client.chat.completions.create({
  model: 'shannon-1.6-lite',
  messages: [
    { role: 'system', content: 'You are a helpful assistant.' },
    { role: 'user', content: 'Hello, Shannon!' }
  ],
  max_tokens: 1024
});

console.log(response.choices[0].message.content);

package main

import (
    "context"
    "fmt"
    openai "github.com/sashabaranov/go-openai"
)

func main() {
    config := openai.DefaultConfig("YOUR_API_KEY")
    config.BaseURL = "https://api.shannon-ai.com/v1"
    client := openai.NewClientWithConfig(config)

    resp, err := client.CreateChatCompletion(
        context.Background(),
        openai.ChatCompletionRequest{
            Model: "shannon-1.6-lite",
            Messages: []openai.ChatCompletionMessage{
                {Role: "system", Content: "You are a helpful assistant."},
                {Role: "user", Content: "Hello, Shannon!"},
            },
            MaxTokens: 1024,
        },
    )
    if err != nil {
        panic(err)
    }
    fmt.Println(resp.Choices[0].Message.Content)
}

cURL

curl -X POST "https://api.shannon-ai.com/v1/chat/completions" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "shannon-1.6-lite",
    "messages": [
      {"role": "system", "content": "You are a helpful assistant."},
      {"role": "user", "content": "Hello, Shannon!"}
    ],
    "max_tokens": 1024
  }'

Format de réponse

Réponse réussie

{
  "id": "chatcmpl-abc123",
  "object": "chat.completion",
  "created": 1234567890,
  "model": "Shannon 1.6 Lite",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Hello! I'm Shannon, your AI assistant. How can I help you today?"
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 25,
    "completion_tokens": 18,
    "total_tokens": 43
  }
}

Terrain de jeu API

Nouveau

Testez l'API Shannon directement dans votre navigateur. Créez votre demande, exécutez-la et voyez la réponse en temps réel.

Chat, Responses, Messages

Switch across OpenAI Chat Completions, Responses, and Anthropic Messages without leaving the playground.

Stream live output

Run real requests, inspect raw JSON, and view stream events from the same operator console.

Reuse your key

Signed-in users can pull their Shannon API key straight into the dedicated playground workspace.

/fr/docs/playground

The playground now lives on its own route so the API docs stay Astro-rendered while the request builder remains an explicitly interactive client tool.

Essayez le terrain de jeu V2 Obtenez votre clé API

Authentification

Toutes les requêtes API nécessitent une authentification à l'aide de votre clé API Shannon.

Format OpenAI (recommandé)

HTTP

Authorization: Bearer YOUR_API_KEY

Format anthropique

HTTP

X-API-Key: YOUR_API_KEY
anthropic-version: 2023-06-01

Modèles

Shannon propose plusieurs modèles optimisés pour différents cas d'utilisation.

shannon-1.6-lite Shannon 1.6 Lite

Des réponses rapides et efficaces pour les tâches quotidiennes

Contexte 128K

Idéal pour Chat, questions et réponses, génération de contenu

shannon-1.6-pro Shannon 1.6 Pro

Raisonnement avancé pour des problèmes complexes

Contexte 128K

Idéal pour Analyse, recherche, tâches complexes

shannon-2-lite Shannon 2 Lite

Contexte 128K

Idéal pour

shannon-2-pro Shannon 2 Pro

Contexte 128K

Idéal pour

shannon-coder-1 Shannon Coder

Optimisé pour Claude Code CLI avec quota basé sur les appels

Contexte 128K

Idéal pour Génération de code, utilisation des outils, intégration CLI

Quota basé sur les appels

Appel de fonction

Définissez les outils que Shannon peut appeler pour effectuer des actions ou récupérer des informations.

Python

from openai import OpenAI
import json

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.shannon-ai.com/v1"
)

# Define available tools/functions
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get current weather for a location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "City name, e.g., 'Tokyo'"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"]
                    }
                },
                "required": ["location"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="shannon-1.6-lite",
    messages=[{"role": "user", "content": "What's the weather in Tokyo?"}],
    tools=tools,
    tool_choice="auto"
)

# Check if model wants to call a function
if response.choices[0].message.tool_calls:
    tool_call = response.choices[0].message.tool_calls[0]
    print(f"Function: {tool_call.function.name}")
    print(f"Arguments: {tool_call.function.arguments}")

JavaScript

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'YOUR_API_KEY',
  baseURL: 'https://api.shannon-ai.com/v1'
});

const tools = [
  {
    type: 'function',
    function: {
      name: 'get_weather',
      description: 'Get current weather for a location',
      parameters: {
        type: 'object',
        properties: {
          location: { type: 'string', description: "City name" },
          unit: { type: 'string', enum: ['celsius', 'fahrenheit'] }
        },
        required: ['location']
      }
    }
  }
];

const response = await client.chat.completions.create({
  model: 'shannon-1.6-lite',
  messages: [{ role: 'user', content: "What's the weather in Tokyo?" }],
  tools,
  tool_choice: 'auto'
});

if (response.choices[0].message.tool_calls) {
  const toolCall = response.choices[0].message.tool_calls[0];
  console.log('Function:', toolCall.function.name);
  console.log('Arguments:', toolCall.function.arguments);
}

Options de choix d'outils

"auto" Le modèle décide d'appeler ou non une fonction (par défaut)

"none" Désactiver la fonction appelant cette requête

{"type": "function", "function": {"name": "..."}} Forcer un appel de fonction spécifique

Réponse à l'appel de fonction

Quand le modèle appelle une fonction

{
  "id": "chatcmpl-xyz",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": null,
        "tool_calls": [
          {
            "id": "call_abc123",
            "type": "function",
            "function": {
              "name": "get_weather",
              "arguments": "{\"location\": \"Tokyo\", \"unit\": \"celsius\"}"
            }
          }
        ]
      },
      "finish_reason": "tool_calls"
    }
  ]
}

Résultats structurés

Forcez Shannon à répondre avec un JSON valide qui correspond à votre schéma.

Python

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.shannon-ai.com/v1"
)

# Force JSON output with schema
response = client.chat.completions.create(
    model="shannon-1.6-lite",
    messages=[
        {"role": "user", "content": "Extract: John Doe, 30 years old, engineer"}
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "person_info",
            "schema": {
                "type": "object",
                "properties": {
                    "name": {"type": "string"},
                    "age": {"type": "integer"},
                    "occupation": {"type": "string"}
                },
                "required": ["name", "age", "occupation"]
            }
        }
    }
)

import json
data = json.loads(response.choices[0].message.content)
print(data)  # {"name": "John Doe", "age": 30, "occupation": "engineer"}

JavaScript

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'YOUR_API_KEY',
  baseURL: 'https://api.shannon-ai.com/v1'
});

const response = await client.chat.completions.create({
  model: 'shannon-1.6-lite',
  messages: [
    { role: 'user', content: 'Extract: John Doe, 30 years old, engineer' }
  ],
  response_format: {
    type: 'json_schema',
    json_schema: {
      name: 'person_info',
      schema: {
        type: 'object',
        properties: {
          name: { type: 'string' },
          age: { type: 'integer' },
          occupation: { type: 'string' }
        },
        required: ['name', 'age', 'occupation']
      }
    }
  }
});

const data = JSON.parse(response.choices[0].message.content);
console.log(data); // { name: "John Doe", age: 30, occupation: "engineer" }

Options de format de réponse

{"type": "json_object"} Forcer la sortie JSON valide (pas de schéma spécifique)

{"type": "json_schema", "json_schema": {...}} Forcer la sortie correspondant exactement à votre schéma

Diffusion en continu

Activez le streaming de jetons en temps réel avec les événements envoyés par le serveur pour des interfaces utilisateur réactives.

Python

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.shannon-ai.com/v1"
)

# Enable streaming for real-time responses
stream = client.chat.completions.create(
    model="shannon-1.6-lite",
    messages=[
        {"role": "user", "content": "Write a short poem about AI"}
    ],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

JavaScript

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'YOUR_API_KEY',
  baseURL: 'https://api.shannon-ai.com/v1'
});

// Enable streaming for real-time responses
const stream = await client.chat.completions.create({
  model: 'shannon-1.6-lite',
  messages: [
    { role: 'user', content: 'Write a short poem about AI' }
  ],
  stream: true
});

for await (const chunk of stream) {
  const content = chunk.choices[0]?.delta?.content;
  if (content) process.stdout.write(content);
}

Astuce : Les réponses en streaming arrivent sous forme d’événements envoyés par le serveur. Chaque morceau contient un delta avec un contenu partiel.

Recherche Web intégrée

Shannon inclut une fonction web_search intégrée qui est automatiquement disponible.

Python

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.shannon-ai.com/v1"
)

# Web search is automatically available!
# Shannon will use it when needed for current information

response = client.chat.completions.create(
    model="shannon-1.6-lite",
    messages=[
        {"role": "user", "content": "What are the latest AI news today?"}
    ],
    # Optionally, explicitly define web_search tool
    tools=[{
        "type": "function",
        "function": {
            "name": "web_search",
            "description": "Search the web for current information",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "Search query"}
                },
                "required": ["query"]
            }
        }
    }]
)

print(response.choices[0].message.content)
# Response includes sources and citations

JavaScript

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'YOUR_API_KEY',
  baseURL: 'https://api.shannon-ai.com/v1'
});

// Web search is automatically available!
// Shannon will use it when needed for current information

const response = await client.chat.completions.create({
  model: 'shannon-1.6-lite',
  messages: [
    { role: 'user', content: 'What are the latest AI news today?' }
  ],
  // Optionally, explicitly define web_search tool
  tools: [{
    type: 'function',
    function: {
      name: 'web_search',
      description: 'Search the web for current information',
      parameters: {
        type: 'object',
        properties: {
          query: { type: 'string', description: 'Search query' }
        },
        required: ['query']
      }
    }
  }]
});

console.log(response.choices[0].message.content);
// Response includes sources and citations

Conseil de pro : Les résultats de recherche sur le Web incluent des citations. Shannon citera automatiquement les sources.

Format anthropique

Shannon prend également en charge le format API Messages d'Anthropic.

https://api.shannon-ai.com/v1/messages

Python

import anthropic

client = anthropic.Anthropic(
    api_key="YOUR_API_KEY",
    base_url="https://api.shannon-ai.com/messages"
)

response = client.messages.create(
    model="shannon-1.6-lite",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Hello, Shannon!"}
    ],
    # Tool use (Anthropic format)
    tools=[{
        "name": "web_search",
        "description": "Search the web",
        "input_schema": {
            "type": "object",
            "properties": {
                "query": {"type": "string"}
            },
            "required": ["query"]
        }
    }]
)

print(response.content[0].text)

JavaScript

import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic({
  apiKey: 'YOUR_API_KEY',
  baseURL: 'https://api.shannon-ai.com/messages'
});

const response = await client.messages.create({
  model: 'shannon-1.6-lite',
  max_tokens: 1024,
  messages: [
    { role: 'user', content: 'Hello, Shannon!' }
  ],
  // Tool use (Anthropic format)
  tools: [{
    name: 'web_search',
    description: 'Search the web',
    input_schema: {
      type: 'object',
      properties: {
        query: { type: 'string' }
      },
      required: ['query']
    }
  }]
});

console.log(response.content[0].text);

En-tête obligatoire : Le format anthropique nécessite la version anthropique : 2023-06-01.

SDK

Compatible

Utilisez n’importe quel SDK OpenAI ou Anthropic – changez simplement l’URL de base.

SDK compatibles OpenAI

SDK Python

SDK OpenAI Python officiel - fonctionne avec Shannon

pip install openai

Afficher les documents ->

SDK JavaScript / TypeScript

SDK officiel OpenAI Node.js - fonctionne avec Shannon

npm install openai

Afficher les documents ->

SDK Go

Client Community Go pour les API compatibles OpenAI

go get github.com/sashabaranov/go-openai

Afficher les documents ->

SDK Ruby

Client Ruby communautaire pour les API compatibles OpenAI

gem install ruby-openai

Afficher les documents ->

SDK PHP

Client PHP communautaire pour les API compatibles OpenAI

composer require openai-php/client

Afficher les documents ->

SDK Rust

Client Async Rust pour les API compatibles OpenAI

cargo add async-openai

Afficher les documents ->

SDK compatibles avec Anthropic

SDK Python (Anthropic)

SDK Anthropic Python officiel - fonctionne avec Shannon

pip install anthropic

Afficher les documents ->

SDK TypeScript (Anthropic)

SDK Anthropic TypeScript officiel - fonctionne avec Shannon

npm install @anthropic-ai/sdk

Afficher les documents ->

Gestion des erreurs

Shannon utilise des codes d'état HTTP standard et renvoie des messages d'erreur détaillés.

400 Mauvaise demande Format ou paramètres de demande invalides

401 Non autorisé Clé API invalide ou manquante

402 Quota dépassé Jeton ou quota de recherche dépassé

429 Tarif Limité Trop de demandes, ralentissez

500 Erreur de serveur Erreur interne, réessayez plus tard

Format de réponse d'erreur

Réponse à l'erreur

{
  "error": {
    "message": "Invalid API key provided",
    "type": "authentication_error",
    "code": "invalid_api_key"
  }
}

Journal des modifications

LOG

Mises à jour et améliorations récentes de l'API Shannon.

v2.1.0

2025-01-03

Nouveau Ajout du modèle shannon-coder-1 pour l'intégration Claude Code CLI
Nouveau Système de quota basé sur les appels pour le modèle Coder
Amélioré Fiabilité améliorée des appels de fonction

v2.0.0

2024-12-15

Nouveau Ajout de la compatibilité de l'API Anthropic Messages
Nouveau Exécution d'outils multi-tours (jusqu'à 10 itérations)
Nouveau JSON Prise en charge du format de réponse du schéma
Amélioré Recherche Web améliorée avec de meilleures citations

v1.5.0

2024-11-20

Nouveau Ajout du modèle Shannon-deep-dapo pour un raisonnement complexe
Nouveau Fonction web_search intégrée
Amélioré Latence réduite pour les réponses en streaming

v1.0.0

2024-10-01

Nouveau Version initiale de l'API
Nouveau Point de terminaison de complétion de chat compatible avec OpenAI
Nouveau Prise en charge des appels de fonction
Nouveau Streaming via des événements envoyés par le serveur

Votre clé API

Accès

Utilisez les jetons Bearer pour les appels OpenAI ou X-API-Key + version anthropique.

YOUR_API_KEY

Obtenez votre clé API

Gardez votre clé API secrète. La régénération crée une nouvelle clé et invalide l'ancienne.

Votre utilisation

Affichez la consommation de jetons et de recherche sur cette page lorsque vous êtes connecté à votre compte.

-- Appels API

-- Jetons utilisés

API Shannon

Aperçu

Capacités

Remplacement instantané

Appel de fonction

Recherche Web intégrée

Résultats structurés

Outils multi-tours

Diffusion en continu

Démarrage rapide

Définissez votre URL de base

Ajoutez votre clé API

Envoyez votre premier message

Format de réponse

Terrain de jeu API

Chat, Responses, Messages

Stream live output

Reuse your key

Authentification

Format OpenAI (recommandé)

Format anthropique

Modèles

Appel de fonction

Options de choix d'outils

Réponse à l'appel de fonction

Résultats structurés

Options de format de réponse

Diffusion en continu

Recherche Web intégrée

Format anthropique

SDK

SDK compatibles OpenAI

SDK compatibles avec Anthropic

Gestion des erreurs

Format de réponse d'erreur

Journal des modifications

Votre clé API

Votre utilisation

Codeur Shannon (shannon-coder-1)

Prêt à construire ?

Shannon AI API Documentation

Aperçu

Capacités

Remplacement instantané

Appel de fonction

Recherche Web intégrée

Résultats structurés

Outils multi-tours

Diffusion en continu

Démarrage rapide

Définissez votre URL de base

Ajoutez votre clé API

Envoyez votre premier message

Format de réponse

Terrain de jeu API

Chat, Responses, Messages

Stream live output

Reuse your key

Authentification

Format OpenAI (recommandé)

Format anthropique

Modèles

Appel de fonction

Options de choix d'outils

Réponse à l'appel de fonction

Résultats structurés

Options de format de réponse

Diffusion en continu

Recherche Web intégrée

Format anthropique

SDK

SDK compatibles OpenAI

SDK compatibles avec Anthropic

Gestion des erreurs

Format de réponse d'erreur

Journal des modifications

Votre clé API

Votre utilisation

Codeur Shannon (shannon-coder-1)

Prêt à construire ?