Shannon AI API Dokumentatioun

Iwwersiicht

Ëffentlech Docs

Alles wat Dir braucht, fir mat Shannon senger OpenAI- an Anthropic-kompatibeler API ze starten.

URL OpenAI-kompatibel

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

Benotzt d'Chat Completions API mat Funktiounsofruff a Streaming.

URL Anthropic-kompatibel

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

Claude Messages Format mat Tools an anthropic-version Header.

HTTP Authentifikatioun

Authorization: Bearer <api-key>

Oder X-API-Key mat anthropic-version fir Claude-ähnlech Uruffen.

Zougang Statut

Ëffentlech Docs - Schlëssel néideg fir Uruff

Streaming, Funktiounsofruff, strukturéierte Output, Websich.

Start-Checklist

+

Setzt Ären SDK op Shannon

Setzt baseURL op déi OpenAI- oder Anthropic-Endpunkten hei uewen.

Astellung
+

API-Schlëssel uginn

Benotzt Bearer Tokens fir OpenAI-Uruffen oder X-API-Key + anthropic-version.

Sécherheet
+

Tools & strukturéiert Output aktivéieren

Ënnerstëtzt OpenAI Tools/Funktiounen, JSON Schema an built-in web_search.

Fäegkeeten
+

Nutzung verfollegen

Gesäit Token- a Sichverbrauch op dëser Säit, wann Dir ageloggt sidd.

Analytiken

Fäegkeeten

OpenAI + Anthropic

Drop-in Ersatz fir OpenAI- an Anthropic-APIs mat native Support fir Tools, strukturéierte Output an integréiert Websich.

Drop-in Ersatz

Kompatibel

Schafft mat OpenAI- an Anthropic-SDKs. Ännert just d'Base URL.

Funktiounsofruff

Wierkzeugen

Definéiert Tools, loosst Shannon se ruffen. Ënnerstëtzt auto-, forced- an none-Modi.

Integréiert Websich

Sich

Websich an Echtzäit mat Quellennennungen. Automatesch disponibel.

Strukturéiert Output

JSON

JSON-Modus an JSON-Schema-Erzwingung fir zouverlässeg Donnéeausliesen.

Multi-turn Wierkzeugen

Agentësch

Automatesch Funktiouns-Exekutiounsschleifen. Bis zu 10 Iteratiounen pro Ufro.

Streaming

Séier

Server-sent events fir Echtzäit Token-Streaming.

Schnellstart

5 Minutten

Start an dräi Schrëtt. Shannon spigelt OpenAI- an Anthropic-Clients.

Base URL setzen

Benotzt den OpenAI-kompatiblen Endpunkt.

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

API-Schlëssel derbäisetzen

Bearer-Auth am Authorization-Header benotzen.

Éischt Noriicht schécken

Sprooch auswielen an Äre Schlëssel androen.

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
  }'

Äntwertformat

Succès-Äntwert

{
  "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
  }
}

API-Playground

Nei

Test d'Shannon API direkt am Browser. Baut Är Ufro, fuert se aus a kuckt d'Äntwert an Echtzäit.

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.

/lb/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.

Playground testen V2 Kritt Ären API-Schlëssel

Authentifikatioun

All API-Ufroe brauchen Authentifikatioun mat Ärem Shannon API-Schlëssel.

OpenAI Format (Recommandéiert)

HTTP

Authorization: Bearer YOUR_API_KEY

Anthropic-Format

HTTP

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

Modeller

Shannon bitt verschidde Modeller fir ënnerschiddlech Use-Casen optiméiert.

shannon-1.6-lite Shannon 1.6 Lite

Séier, effizient Äntwerten fir Alldagsaufgaben

Kontext 128K

Bescht fir Chat, Q&A, Content Generatioun

shannon-1.6-pro Shannon 1.6 Pro

Fortgeschratt Reasoning fir komplex Problemer

Kontext 128K

Bescht fir Analys, Fuerschung, Komplex Aufgaben

shannon-2-lite Shannon 2 Lite

Kontext 128K

Bescht fir

shannon-2-pro Shannon 2 Pro

Kontext 128K

Bescht fir

shannon-coder-1 Shannon Coder

Optimiséiert fir Claude Code CLI mat call-baséierter Quota

Kontext 128K

Bescht fir Code Generatioun, Tool-Notzung, CLI-Integratioun

Call-baséiert Quota

Funktiounsofruff

Definéiert Tools déi Shannon uruffe kann fir Aktiounen auszeféieren oder Informatioun ze kréien.

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);
}

Tool-Auswiel Optiounen

"auto" Modell entscheet ob eng Funktioun geruff gëtt (Standard)

"none" Funktiounsofruff fir dës Ufro deaktivéieren

{"type": "function", "function": {"name": "..."}} Eng spezifesch Funktiounsfro erzwingen

Funktiounsofruff-Äntwert

Wann d'Modell eng Funktioun rifft

{
  "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"
    }
  ]
}

Strukturéiert Output

Forcéiert Shannon mat valabelen JSON z'äntweren, dat Är Schema entsprécht.

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" }

Äntwertformat Optiounen

{"type": "json_object"} Valabelen JSON Output forcéieren (kee spezifesche Schema)

{"type": "json_schema", "json_schema": {...}} Output forcéieren deen Ärem exakte Schema entsprécht

Streaming

Echtzäit Token-Streaming mat Server-Sent Events fir reaktiounsfäeg UIs.

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);
}

Tipp: Streaming-Äntwerten kommen als Server-Sent Events. All Chunk enthält en Delta mat deelweisem Inhalt.

Integréiert Websich

Shannon enthält eng built-in web_search Funktioun déi automatesch disponibel ass.

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

Pro Tipp: Websich-Resultater enthalen Zitater. Shannon zitéiert automatesch Quellen.

Anthropic-Format

Shannon ënnerstëtzt och den Anthropic Messages API Format.

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);

Noutwennege Header: Anthropic-Format verlaangt anthropic-version: 2023-06-01.

CLI Coding Agents

NEW

Use Shannon as the AI backend for popular CLI coding agents. Read files, edit code, run tests — all powered by Shannon's API.

CLI Claude Code

Anthropic's official CLI coding agent. Point it at Shannon to use as your AI backend for reading, editing, and running code directly in your terminal.

ANTHROPIC_BASE_URL=https://api.shannon-ai.com ANTHROPIC_API_KEY=sk-YOUR_KEY claude --bare

Dokumenter kucken ->

CLI Codex CLI

OpenAI's open-source coding agent. Uses the Responses API for multi-turn tool use, file editing, and shell commands — all routed through Shannon.

OPENAI_BASE_URL=https://api.shannon-ai.com/v1 OPENAI_API_KEY=sk-YOUR_KEY codex

Dokumenter kucken ->

Claude Code

Anthropic's official CLI coding agent. Set two environment variables and launch with --bare to skip Anthropic account login.

Bash

# Install Claude Code (requires Node.js 18+)
npm install -g @anthropic-ai/claude-code

# Connect to Shannon AI as backend
export ANTHROPIC_BASE_URL=https://api.shannon-ai.com
export ANTHROPIC_API_KEY=sk-YOUR_API_KEY

# Launch Claude Code in bare mode (no Anthropic account needed)
claude --bare

# Or run a one-shot command
claude --bare -p "Explain this codebase"

# Claude Code will use Shannon's Anthropic-compatible API
# for all AI operations: reading files, editing code,
# running tests, and multi-turn tool use.

Shell Config

# Alternative: set env vars permanently in your shell profile
# ~/.bashrc or ~/.zshrc

export ANTHROPIC_BASE_URL=https://api.shannon-ai.com
export ANTHROPIC_API_KEY=sk-YOUR_API_KEY

# Then just run:
claude --bare

# Supported features through Shannon:
# - Multi-turn conversations with full context
# - File reading and editing (tool use)
# - Shell command execution
# - Streaming responses
# - All Claude Code slash commands (/compact, /clear, etc.)

Codex CLI

OpenAI's open-source coding agent. Uses the Responses API for multi-turn tool use, file editing, and shell commands.

Bash

# Install Codex CLI
npm install -g @openai/codex

# Connect to Shannon AI as backend
export OPENAI_BASE_URL=https://api.shannon-ai.com/v1
export OPENAI_API_KEY=sk-YOUR_API_KEY

# Launch Codex
codex

# Or run a one-shot command
codex "fix the bug in main.py"

# Codex uses the Responses API (POST /v1/responses)
# Shannon handles tool calls including:
# - Reading and writing files
# - Running shell commands
# - Multi-turn function calling

Shell Config

# Alternative: set env vars permanently
# ~/.bashrc or ~/.zshrc

export OPENAI_BASE_URL=https://api.shannon-ai.com/v1
export OPENAI_API_KEY=sk-YOUR_API_KEY

# Then just run:
codex

# Supported features through Shannon:
# - Responses API with full tool use
# - Function calling (file read/write, shell exec)
# - Streaming with real-time output
# - Multi-turn conversations
# - All Codex approval modes (suggest, auto-edit, full-auto)

How It Works: Both tools send standard API requests (Anthropic Messages or OpenAI Responses) to Shannon. Shannon routes them through Gemini with full tool-use support. No Anthropic or OpenAI account needed — just your Shannon API key.

SDKen

Kompatibel

Benotzt all OpenAI oder Anthropic SDK — ännert just d'Base URL.

OpenAI-kompatibel SDKs

SDK Python

Offiziellt OpenAI Python SDK - funktionéiert mat Shannon

pip install openai

Dokumenter kucken ->

SDK JavaScript / TypeScript

Offiziellt OpenAI Node.js SDK - funktionéiert mat Shannon

npm install openai

Dokumenter kucken ->

SDK Go

Community Go Client fir OpenAI-kompatibel APIs

go get github.com/sashabaranov/go-openai

Dokumenter kucken ->

SDK Ruby

Community Ruby Client fir OpenAI-kompatibel APIs

gem install ruby-openai

Dokumenter kucken ->

SDK PHP

Community PHP Client fir OpenAI-kompatibel APIs

composer require openai-php/client

Dokumenter kucken ->

SDK Rust

Async Rust Client fir OpenAI-kompatibel APIs

cargo add async-openai

Dokumenter kucken ->

Anthropic-kompatibel SDKs

SDK Python (Anthropic)

Offiziellt Anthropic Python SDK - funktionéiert mat Shannon

pip install anthropic

Dokumenter kucken ->

SDK TypeScript (Anthropic)

Offiziellt Anthropic TypeScript SDK - funktionéiert mat Shannon

npm install @anthropic-ai/sdk

Dokumenter kucken ->

Feelerbehandlung

Shannon benotzt Standard-HTTP-Statuscoden a liwwert detailléiert Feeler-Noriichten.

400 Feelerhaft Ufro Ongëltege Request-Format oder Parameter

401 Net autoriséiert Ongëltegen oder feelenden API-Schlëssel

402 Quota iwwerschratt Token- oder Sichquota iwwerschratt

429 Rate limitéiert Ze vill Ufroen, lues maachen

500 Serverfeeler Intern Feeler, spéider nach eng Kéier probéieren

Feeler-Äntwertformat

Feeler-Äntwert

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

Ännerungslog

LOG

Rezent Aktualiséierungen an Verbesserungen un der Shannon API.

v2.2.0

2026-03-28

Nei Claude Code support — use Shannon as your Anthropic backend for the official CLI coding agent
Nei Codex CLI support — full Responses API with multi-turn tool use for OpenAI's coding agent
Verbessert Anthropic streaming format fixes — proper content_block lifecycle, tool_use deltas, toolu_ prefixes
Verbessert Schema sanitization for Gemini — strips $schema, additionalProperties, $ref and other unsupported fields from tool schemas

v2.1.0

2025-01-03

Nei shannon-coder-1 Modell fir Claude Code CLI Integratioun derbäi
Nei Call-baséiert Quota System fir Coder Modell
Verbessert Funktiounsofruff Zouverlässegkeet verbessert

v2.0.0

2024-12-15

Nei Anthropic Messages API Kompatibilitéit derbäi
Nei Multi-turn Tool-Exekutioun (bis zu 10 Iteratiounen)
Nei JSON Schema Äntwertformat Support
Verbessert Verbessert Websich mat bessere Zitater

v1.5.0

2024-11-20

Nei shannon-deep-dapo Modell fir komplex Reasoning derbäi
Nei Built-in web_search Funktioun
Verbessert Latenz fir Streaming-Äntwerten reduzéiert

v1.0.0

2024-10-01

Nei Éischt API-Release
Nei OpenAI-kompatiblen Chat-Completions Endpunkt
Nei Funktiounsofruff Support
Nei Streaming iwwer Server-Sent Events

Ären API-Schlëssel

Zougang

Benotzt Bearer Tokens fir OpenAI-Uruffen oder X-API-Key + anthropic-version.

YOUR_API_KEY

Kritt Ären API-Schlëssel

Halt Ären API-Schlëssel geheim. Nei Generatioun mécht en neie Schlëssel a mécht den ale ongëlteg.

Är Notzung

Gesäit Token- a Sichverbrauch op dëser Säit, wann Dir ageloggt sidd.

-- API-Uruffen

-- Tokens benotzt

Shannon AI API Documentation

Iwwersiicht

Fäegkeeten

Drop-in Ersatz

Funktiounsofruff

Integréiert Websich

Strukturéiert Output

Multi-turn Wierkzeugen

Streaming

Schnellstart

Base URL setzen

API-Schlëssel derbäisetzen

Éischt Noriicht schécken

Äntwertformat

API-Playground

Chat, Responses, Messages

Stream live output

Reuse your key

Authentifikatioun

OpenAI Format (Recommandéiert)

Anthropic-Format

Modeller

Funktiounsofruff

Tool-Auswiel Optiounen

Funktiounsofruff-Äntwert

Strukturéiert Output

Äntwertformat Optiounen

Streaming

Integréiert Websich

Anthropic-Format

CLI Coding Agents

Claude Code

Codex CLI

SDKen

OpenAI-kompatibel SDKs

Anthropic-kompatibel SDKs

Feelerbehandlung

Feeler-Äntwertformat

Ännerungslog

Ären API-Schlëssel

Är Notzung

Shannon Coder (shannon-coder-1)

Bereet fir ze bauen?