Documentation Moon AI

curl https://api.moon-ai.fr/v1/chat/completions \
  -H "Authorization: Bearer mk_live_votre_cle_api" \
  -H "Content-Type: application/json"

from moonai import MoonAI

client = MoonAI(
    api_key="mk_live_votre_cle_api"
)

import MoonAI from '@moonai/sdk';

const client = new MoonAI({
  apiKey: 'mk_live_votre_cle_api'
});

pip install moonai

npm install @moonai/sdk

composer require moonai/moonai-php

from moonai import MoonAI

client = MoonAI(api_key="mk_live_votre_cle_api")

response = client.chat.completions.create(
    model="auto",  # Moon Auto selectionne le meilleur modele
    messages=[
        {"role": "user", "content": "Explique-moi Moon Guard en 3 phrases."}
    ],
    guard=True  # Active Moon Guard
)

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

import MoonAI from '@moonai/sdk';

const client = new MoonAI({ apiKey: 'mk_live_votre_cle_api' });

const response = await client.chat.completions.create({
  model: 'auto',
  messages: [
    { role: 'user', content: 'Explique-moi Moon Guard en 3 phrases.' }
  ],
  guard: true
});

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

curl -X POST https://api.moon-ai.fr/v1/chat/completions \
  -H "Authorization: Bearer mk_live_votre_cle_api" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "auto",
    "messages": [
      {"role": "user", "content": "Explique-moi Moon Guard en 3 phrases."}
    ],
    "guard": true
  }'

{
  "error": {
    "type": "invalid_request_error",
    "message": "Le parametre 'model' est requis.",
    "code": "missing_parameter",
    "param": "model"
  }
}

response = client.chat.completions.create(
    model="auto",
    messages=[
        {"role": "system", "content": "Tu es un assistant technique."},
        {"role": "user", "content": "Comment deployer une app Next.js sur Vercel ?"}
    ],
    guard=True,
    temperature=0.7,
    max_tokens=2048
)

const response = await client.chat.completions.create({
  model: 'auto',
  messages: [
    { role: 'system', content: 'Tu es un assistant technique.' },
    { role: 'user', content: 'Comment deployer une app Next.js sur Vercel ?' }
  ],
  guard: true,
  temperature: 0.7,
  maxTokens: 2048
});

curl -X POST https://api.moon-ai.fr/v1/chat/completions \
  -H "Authorization: Bearer mk_live_..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "auto",
    "messages": [
      {"role": "system", "content": "Tu es un assistant technique."},
      {"role": "user", "content": "Comment deployer une app Next.js sur Vercel ?"}
    ],
    "guard": true,
    "temperature": 0.7,
    "max_tokens": 2048
  }'

stream = client.chat.completions.create(
    model="auto",
    messages=[{"role": "user", "content": "Ecris un poeme sur la lune."}],
    stream=True
)

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

const stream = await client.chat.completions.create({
  model: 'auto',
  messages: [{ role: 'user', content: 'Ecris un poeme sur la lune.' }],
  stream: true
});

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

doc = client.documents.generate(
    prompt="Business plan pour une startup SaaS en cybersecurite",
    format="pdf",
    language="fr"
)

# Telecharger le fichier
with open("business-plan.pdf", "wb") as f:
    f.write(doc.content)

const doc = await client.documents.generate({
  prompt: 'Business plan pour une startup SaaS en cybersecurite',
  format: 'pdf',
  language: 'fr'
});

// Sauvegarder le fichier
await fs.promises.writeFile('business-plan.pdf', doc.content);

result = client.guard.anonymize(
    text="Jean Dupont habite au 12 rue de la Paix, Paris. Son email est jean@example.com"
)

print(result.anonymized_text)
# "[PERSON_1] habite au [ADDRESS_1]. Son email est [EMAIL_1]"

print(result.entities)
# [{"type": "PERSON", "original": "Jean Dupont", "token": "PERSON_1"}, ...]

# Restaurer les donnees originales
restored = client.guard.restore(
    text=result.anonymized_text,
    session_id=result.session_id
)

curl -X POST https://api.moon-ai.fr/v1/guard/anonymize \
  -H "Authorization: Bearer mk_live_..." \
  -H "Content-Type: application/json" \
  -d '{
    "text": "Jean Dupont habite au 12 rue de la Paix, Paris."
  }'

# Utiliser Moon Auto (recommande)
response = client.chat.completions.create(model="auto", ...)

# Forcer un modele specifique
response = client.chat.completions.create(model="claude-opus-4-6", ...)

# La reponse indique le modele utilise
print(response.model)       # "claude-opus-4-6"
print(response.routed_by)   # "moon-auto" ou "user"

# Installation via pip (recommande)
pip install moon-cli

# Lancer Moon CLI
moon

# Installation depuis les sources
git clone https://github.com/stellarrstudio/moon-cli.git
cd moon-cli
pip install -e .

# Lancer Moon CLI
moon

# Installation isolee via pipx
pipx install moon-cli

# Lancer Moon CLI
moon

# Le premier lancement lance la configuration
moon

● M O O N  v0.1.0
  Stellarr Studio

  URL de l'API: https://api.openai.com/v1
  Cle API: sk-...
  Modele: gpt-4o

✓ Configuration sauvegardee

# Variables d'environnement (priorite maximale)
export MOON_API_KEY="sk-..."
export MOON_API_URL="https://api.openai.com/v1"
export MOON_MODEL="gpt-4o"

# Ou configurer via la commande /login
moon
❯ /login

# Fichier .env a la racine de votre projet
MOON_API_KEY=sk-...
MOON_API_URL=https://api.openai.com/v1
MOON_MODEL=gpt-4o

{
  "api_url": "https://api.openai.com/v1",
  "api_key": "sk-...",
  "model": "gpt-4o",
  "temperature": 0.7,
  "max_tokens": 8192,
  "permission_mode": "normal",
  "tools_enabled": true,
  "max_history_messages": 100
}

# Changer de modele
moon --model claude-sonnet-4-20250514

# Mode non-interactif (une seule question)
moon -p "explique ce code"

# YOLO mode — tout approuver automatiquement
moon --yolo

# Mode lecture seule — aucune modification
moon --plan

# Changer de repertoire de travail
moon -C ~/projects/my-app

# Voir la version
moon --version

# Dans le chat
❯ /permissions yolo
❯ /permissions plan
❯ /permissions normal

# Au lancement
moon --yolo
moon --plan

# Voir les templates disponibles
❯ /mcp add

# Ajouter un serveur depuis un template
❯ /mcp add brave-search
❯ /mcp add github
❯ /mcp add filesystem

# Ajouter un serveur custom
❯ /mcp add mon-serveur npx -y @mon/mcp-server

# Demarrer / arreter
❯ /mcp start brave-search
❯ /mcp stop brave-search

# Voir les serveurs configures
❯ /mcp list

# Dans le chat interactif
❯ /update

  verification des mises a jour...

  ● Mise a jour disponible
    installee  v0.1.0
    disponible v0.2.0

  installer ? [Y/n] y

  ✓ Moon CLI mis a jour → v0.2.0
  redemarrez Moon CLI pour appliquer

# Ou via pip directement
pip install --upgrade moon-cli

# Installation
pip install moonai

# Usage
from moonai import MoonAI

client = MoonAI()  # Utilise MOON_API_KEY env var

# Chat
response = client.chat.completions.create(
    model="auto",
    messages=[{"role": "user", "content": "Hello Moon!"}]
)

# Async
from moonai import AsyncMoonAI

async_client = AsyncMoonAI()
response = await async_client.chat.completions.create(...)

// Installation: npm install @moonai/sdk

import MoonAI from '@moonai/sdk';

const client = new MoonAI();  // Uses MOON_API_KEY env var

// Chat completion
const response = await client.chat.completions.create({
  model: 'auto',
  messages: [{ role: 'user', content: 'Hello Moon!' }]
});

// Streaming
const stream = await client.chat.completions.create({
  model: 'auto',
  messages: [{ role: 'user', content: 'Streaming test' }],
  stream: true
});

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

// Installation: composer require moonai/moonai-php

use MoonAI\Client;

$client = new Client(getenv('MOON_API_KEY'));

$response = $client->chat->completions->create([
    'model' => 'auto',
    'messages' => [
        ['role' => 'user', 'content' => 'Hello Moon!']
    ],
    'guard' => true
]);

echo $response->choices[0]->message->content;

webhook = client.webhooks.create(
    url="https://votre-app.com/webhooks/moon",
    events=[
        "chat.completion.created",
        "document.generated",
        "guard.pii_detected"
    ]
)

print(webhook.secret)  # whsec_... pour verifier les signatures

import hmac, hashlib

def verify_signature(payload, signature, secret):
    expected = hmac.new(
        secret.encode(),
        payload.encode(),
        hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(expected, signature)

import crypto from 'crypto';

function verifySignature(payload, signature, secret) {
  const expected = crypto
    .createHmac('sha256', secret)
    .update(payload)
    .digest('hex');
  return crypto.timingSafeEqual(
    Buffer.from(expected),
    Buffer.from(signature)
  );
}