Shannon AI API Gwaro

Pfupiso

Magwaro eruzhinji

Zvose zvaunoda kuti utumire neAPI inoenderana neOpenAI neAnthropic ya Shannon.

URL Inoenderana neOpenAI

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

Shandisa Chat Completions API ine kufona mabasa uye streaming.

URL Inoenderana neAnthropic

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

Claude Messages fomati ine maturusi uye anthropic-version header.

Misoro Kusimbisa

Authorization: Bearer <api-key>

Kana X-API-Key ine anthropic-version kune Claude-style calls.

Kuwana Mamiro

Magwaro eruzhinji - kiyi inodiwa pakufona

Streaming, kufona mabasa, structured outputs, kutsvaga web.

Runyorwa rwekuvhurwa

+

Nongedzera SDK yako kuShannon

Seta baseURL kune OpenAI kana Anthropic endpoints ari pamusoro.

Setapu
+

Batanidza API key yako

Shandisa Bearer tokens kune OpenAI calls kana X-API-Key + anthropic-version.

Chengetedzo
+

Batidza tools & structured outputs

Inotsigira OpenAI tools/functions, JSON schema, uye built-in web_search.

Kugona
+

Tevedza kushandiswa

Paunenge wapinda, ona kushandiswa kwetoken uye kutsvaga papeji iri.

Ongororo

Unyanzvi

OpenAI + Anthropic

Drop‑in kutsiva maAPI eOpenAI neAnthropic ane rutsigiro rwezvishandiso, zvinobuda zvakarongeka, uye kutsvaga pawebhu kwakavakirwa mukati.

Drop‑in Replacement

Inoenderana

Inoshanda neOpenAI neAnthropic SDKs. Chinja base URL chete.

Kufona mabasa

Zvishandiso

Tsanangura tools, Shannon anodzidaidza. Inotsigira auto, forced, uye none modes.

Built‑in Web Search

Kutsvaga

Kutsvaga web munguva chaiyo nemareferenzi. Inowanikwa otomatiki.

Zvinobuda zvakarongeka

JSON

JSON mode uye JSON Schema enforcement yekuburitsa data rakavimbika.

Multi‑turn Tools

Agentic

Automatic function execution loops. Kusvika 10 iterations pachikumbiro.

Kuyerera

Kukurumidza

Server‑Sent Events yeku streaming token munguva chaiyo.

Kutanga nekukurumidza

5 maminitsi

Tanga mumatanho matatu. Shannon inotevedzera vatengi veOpenAI neAnthropic.

Seta base URL yako

Shandisa OpenAI‑compatible endpoint.

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

Wedzera API key yako

Shandisa Bearer auth muAuthorization header.

Tumira mharidzo yako yekutanga

Sarudza mutauro uye chinja kiyi yako.

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

Fomati yemhinduro

Mhinduro yakabudirira

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

Itsva

Edza Shannon API zvakananga mubrowser yako. Gadzira chikumbiro, mhanyisa uye uone mhinduro munguva chaiyo.

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.

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

Edza Playground V2 Tora kiyi yako yeAPI

Kusimbisa

Zvikumbiro zvese zveAPI zvinoda kusimbiswa uchishandisa Shannon API kiyi yako.

OpenAI format (yakakurudzirwa)

HTTP

Authorization: Bearer YOUR_API_KEY

Anthropic format

HTTP

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

Mamodheru

Shannon inopa mamodheru akati wandei akagadzirirwa kushandiswa kwakasiyana.

shannon-1.6-lite Shannon 1.6 Lite

Mhinduro dzinokurumidza uye dzinoshanda pamabasa emazuva ese

Kontekisi 128K

Zvakanakisa Chat, Q&A, Kugadzira Zviri mukati

shannon-1.6-pro Shannon 1.6 Pro

Reasoning yepamusoro yezvinetso zvakaoma

Kontekisi 128K

Zvakanakisa Kuongorora, Kutsvakurudza, Mabasa Akaoma

shannon-2-lite Shannon 2 Lite

Kontekisi 128K

Zvakanakisa

shannon-2-pro Shannon 2 Pro

Kontekisi 128K

Zvakanakisa

shannon-coder-1 Shannon Coder

Yakagadzirirwa Claude Code CLI ine call‑based quota

Kontekisi 128K

Zvakanakisa Kugadzira Kodhi, Kushandisa Tools, CLI Integration

Call‑based quota

Kudanwa kwemabasa

Tsanangura zvishandiso zvinogona kudanwa naShannon kuita zviito kana kuwana ruzivo.

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 choice options

"auto" Modhi inosarudza kana kuita function call (default)

"none" Dzima function calling pachikumbiro ichi

{"type": "function", "function": {"name": "..."}} Manikidza specific function call

Mhinduro yeFunction Call

Kana modhi yadana basa

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

Zvinobuda zvakarongeka

Sundidzira Shannon kupindura neJSON inoshanda inoenderana ne schema yako.

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

Response format options

{"type": "json_object"} Manikidza valid JSON output (pasina schema yakatarwa)

{"type": "json_schema", "json_schema": {...}} Manikidza output inoenderana neschema yako

Kuyerera

Batidza token streaming munguva chaiyo neServer‑Sent Events kuti UI ipindure nekukurumidza.

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

Mazano: Streaming responses anouya seServer‑Sent Events. Chunk imwe neimwe ine delta ine chikamu chemukati.

Kutsvaga pawebhu

Shannon ine built‑in web_search inowanikwa otomatiki.

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

Zano repamusoro: Web search results ane citations. Shannon achataura masosi otomatiki.

Anthropic

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

Header inodiwa: Anthropic format inoda 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

Tarisa Docs ->

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

Tarisa Docs ->

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.

SDKs

Inoenderana

Shandisa chero OpenAI kana Anthropic SDK — shandura base URL chete.

OpenAI‑Compatible SDKs

SDK Python

Official OpenAI Python SDK - inoshanda neShannon

pip install openai

Tarisa Docs ->

SDK JavaScript / TypeScript

Official OpenAI Node.js SDK - inoshanda neShannon

npm install openai

Tarisa Docs ->

SDK Go

Community Go client yeOpenAI‑compatible APIs

go get github.com/sashabaranov/go-openai

Tarisa Docs ->

SDK Ruby

Community Ruby client yeOpenAI‑compatible APIs

gem install ruby-openai

Tarisa Docs ->

SDK PHP

Community PHP client yeOpenAI‑compatible APIs

composer require openai-php/client

Tarisa Docs ->

SDK Rust

Async Rust client yeOpenAI‑compatible APIs

cargo add async-openai

Tarisa Docs ->

Anthropic‑Compatible SDKs

SDK Python (Anthropic)

Official Anthropic Python SDK - inoshanda neShannon

pip install anthropic

Tarisa Docs ->

SDK TypeScript (Anthropic)

Official Anthropic TypeScript SDK - inoshanda neShannon

npm install @anthropic-ai/sdk

Tarisa Docs ->

Zvikanganiso

Shannon inoshandisa standard HTTP status codes uye inodzosa mashoko eruzivo rwemhosho.

400 Chikumbiro chisiri iko Fomati isiri iyo kana maparamita

401 Hapana mvumo API key isiriyo kana isipo

402 Quota yapfuura Token kana search quota yapfuura

429 Rate limit Zvakawandisa zvikumbiro, deredza

500 Kukanganisa server Kukanganisa kwemukati, edza zvakare

Fomati yemhinduro yechikanganiso

Mhinduro yechikanganiso

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

Rekodhi yeshanduko

LOG

Zvigadziriso zvichangoburwa uye kuvandudzwa kuShannon API.

v2.2.0

2026-03-28

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

v2.1.0

2025-01-03

Itsva Yakawedzera shannon-coder-1 model yeClaude Code CLI integration
Itsva Call‑based quota system yemodhi Coder
Yakavandudzwa Kuvimbika kwefunction calling kwakavandudzwa

v2.0.0

2024-12-15

Itsva Kuwirirana neAnthropic Messages API kwawedzerwa
Itsva Multi‑turn tool execution (kusvika 10 iterations)
Itsva Rutsigiro rwe JSON Schema response format
Yakavandudzwa Web search yakagadziridzwa nemareferenzi ari nani

v1.5.0

2024-11-20

Itsva Yakawedzera shannon-deep-dapo model yezvinetso zvakaoma
Itsva Built‑in web_search function
Yakavandudzwa Latency yederedzwa ye streaming responses

v1.0.0

2024-10-01

Itsva Kutangwa kweAPI kwekutanga
Itsva OpenAI‑compatible chat completions endpoint
Itsva Rutsigiro rwe function calling
Itsva Streaming kuburikidza neServer‑Sent Events

Kiyi yeAPI

Kuwana

Shandisa Bearer tokens kune OpenAI calls kana X-API-Key + anthropic-version.

YOUR_API_KEY

Tora kiyi yako yeAPI

Chengeta API key yako yakavanzika. Kugadzira patsva kunogadzira kiyi nyowani uye kunodzima yekare.

Kushandisa

Paunenge wapinda, ona kushandiswa kwetoken uye kutsvaga papeji iri.

-- Kufona kweAPI

-- Tokeni dzakashandiswa

Shannon AI API Documentation

Pfupiso

Unyanzvi

Drop‑in Replacement

Kufona mabasa

Built‑in Web Search

Zvinobuda zvakarongeka

Multi‑turn Tools

Kuyerera

Kutanga nekukurumidza

Seta base URL yako

Wedzera API key yako

Tumira mharidzo yako yekutanga

Fomati yemhinduro

API Playground

Chat, Responses, Messages

Stream live output

Reuse your key

Kusimbisa

OpenAI format (yakakurudzirwa)

Anthropic format

Mamodheru

Kudanwa kwemabasa

Tool choice options

Mhinduro yeFunction Call

Zvinobuda zvakarongeka

Response format options

Kuyerera

Kutsvaga pawebhu

Anthropic

CLI Coding Agents

Claude Code

Codex CLI

SDKs

OpenAI‑Compatible SDKs

Anthropic‑Compatible SDKs

Zvikanganiso

Fomati yemhinduro yechikanganiso

Rekodhi yeshanduko

Kiyi yeAPI

Kushandisa

Shannon Coder (shannon-coder-1)

Wagadzirira kuvaka?