curl -X POST https://ai.bakeli.tech/v1/chat \
  -H "Authorization: Bearer <ta-cle-api>" \
  -H "Content-Type: application/json" \
  -d '{"model":"openai/gpt-oss-20b","messages":[{"role":"user","content":"Bonjour !"}]}'

{ "model": "openai/gpt-oss-20b", "message": { "role": "assistant", "content": "Bonjour !" }, "done": true }

Authorization: Bearer <API_KEY>

{ "error": "Unauthorized" }

BAKELI_AI_URL=https://ai.bakeli.tech
BAKELI_AI_KEY=ta-cle-api-secrete

{
  "model":           "gemini-3-flash-preview",
  "message":         { "role": "assistant", "content": "Docker est..." },
  "done":            true,
  "fallback":        true,
  "fallback_reason": "Groq rate limit"
}

{
  "model":           "gemini-2.5-flash",
  "message":         { "role": "assistant", "content": "Docker est..." },
  "done":            true,
  "fallback":        true,
  "fallback_reason": "Groq rate limit → gemini-3-flash-preview quota épuisé"
}

{
  "model":           "llama3.2",
  "message":         { "role": "assistant", "content": "Docker est..." },
  "done":            true,
  "fallback":        true,
  "fallback_reason": "Groq rate limit → tous modèles Gemini épuisés"
}

Tentative 1-3 :
  gemini-3-flash-preview → gemini-2.5-flash
  ↓ (si tous échouent, attente 120s entre tentatives)

Fallback final :
  Ollama (llama3.2-vision pour images, llama3.2 pour autres fichiers)

Taux de succès : ~99.9% (7 essais au total)

{
  "message": {
    "role": "assistant",
    "content": "Cette image montre..."
  },
  "done": true
}

{
  "model": "llama3.2-vision",
  "message": {
    "role": "assistant",
    "content": "Cette image montre..."
  },
  "done": true,
  "fallback": true,
  "fallback_reason": "Tous les modèles Gemini indisponibles après 3 tentatives"
}

{
  "model": "gemini-3-flash-preview",
  "data": {
    "numero_facture": "FAC-2024-001",
    "date": "2024-03-15",
    "montant_total": 1250.00,
    "articles": [
      { "nom": "Ordinateur portable", "quantite": 1, "prix_unitaire": 1000.00 },
      { "nom": "Souris sans fil", "quantite": 2, "prix_unitaire": 125.00 }
    ]
  },
  "raw_text": "```json\n{...}\n```",
  "done": true
}

{
  "model": "gemini-3-flash-preview",
  "data": null,
  "raw_text": "Voici les données extraites: ...",
  "done": true,
  "warning": "Réponse non-JSON, voir raw_text"
}

{
  "model": "gemini-3-flash-preview",
  "text": "Le document contient les informations suivantes:\n- Numéro: FAC-2024-001\n- Date: 15/03/2024\n...",
  "done": true
}

{
  "model": "gemini-2.5-flash",
  "data": { /* ... */ },
  "done": true,
  "fallback": true,
  "fallback_reason": "gemini-3-flash-preview quota épuisé"
}

{
  "model": "llama3.2",
  "data": { /* ... */ },
  "done": true,
  "fallback": true,
  "fallback_reason": "Gemini indisponible"
}

curl https://ai.bakeli.tech/v1/models -H "Authorization: Bearer <API_KEY>"

{
  "models": [
    { "name": "llama3.2:latest", "size": 2019383552 },
    { "name": "mistral:latest",  "size": 4109854720 },
    { "name": "llama-3.3-70b-versatile", "provider": "groq" },
    { "name": "mixtral-8x7b-32768",      "provider": "groq" }
  ]
}

curl https://ai.bakeli.tech/v1/health

{ "RedTeam": "ok", "ollama": "ok" }

{ "RedTeam": "ok", "ollama": "unreachable" }

BAKELI_AI_URL=https://ai.bakeli.tech
BAKELI_AI_KEY=ta-cle-api

BAKELI_AI_URL = env("BAKELI_AI_URL", default="https://ai.bakeli.tech")
BAKELI_AI_KEY = env("BAKELI_AI_KEY")

import requests
from django.conf import settings

def ask(messages: list, model: str = "openai/gpt-oss-20b") -> str:
    """Envoie une conversation, retourne le texte de réponse."""
    resp = requests.post(
        f"{settings.BAKELI_AI_URL}/v1/chat",
        headers={"Authorization": f"Bearer {settings.BAKELI_AI_KEY}"},
        json={"model": model, "messages": messages},
        timeout=120,
    )
    resp.raise_for_status()
    return resp.json()["message"]["content"]

def ask_with_file(prompt: str, filepath: str, model: str = "openai/gpt-oss-20b") -> str:
    """Envoie un fichier avec un prompt."""
    with open(filepath, "rb") as f:
        resp = requests.post(
            f"{settings.BAKELI_AI_URL}/v1/chat/file",
            headers={"Authorization": f"Bearer {settings.BAKELI_AI_KEY}"},
            data={"prompt": prompt, "model": model},
            files={"file": f},
            timeout=180,
        )
    return resp.json()["message"]["content"]

from utils.ai_client import ask

def assistant(request):
    historique = request.session.get("chat_history", [])
    historique.append({"role": "user", "content": request.POST.get("message")})
    reponse = ask(historique)
    historique.append({"role": "assistant", "content": reponse})
    request.session["chat_history"] = historique
    return JsonResponse({"reponse": reponse})

BAKELI_AI_URL=https://ai.bakeli.tech
BAKELI_AI_KEY=ta-cle-api

<?php
return [
    'url'     => env('BAKELI_AI_URL', 'https://ai.bakeli.tech'),
    'key'     => env('BAKELI_AI_KEY'),
    'model'   => env('BAKELI_AI_MODEL', 'openai/gpt-oss-20b'),
    'timeout' => 120,
];

<?php
namespace App\Services;
use Illuminate\Support\Facades\Http;

class AiService
{
    private string $url, $key, $model;

    public function __construct() {
        $this->url   = config('ai.url');
        $this->key   = config('ai.key');
        $this->model = config('ai.model');
    }

    public function ask(array $messages, string $model = null): string
    {
        return Http::withToken($this->key)
            ->timeout(config('ai.timeout'))
            ->post($this->url . '/v1/chat', [
                'model'    => $model ?? $this->model,
                'messages' => $messages,
            ])->throw()->json('message.content');
    }

    public function askWithFile(string $prompt, string $path, string $model = null): string
    {
        return Http::withToken($this->key)
            ->timeout(180)
            ->attach('file', file_get_contents($path), basename($path))
            ->post($this->url . '/v1/chat/file', [
                'prompt' => $prompt,
                'model'  => $model ?? $this->model,
            ])->throw()->json('message.content');
    }
}

class AssistantController extends Controller
{
    public function __construct(private AiService $ai) {}

    public function chat(Request $request)
    {
        $history   = session('chat_history', []);
        $history[] = ['role' => 'user', 'content' => $request->input('message')];
        $reply     = $this->ai->ask($history);
        $history[] = ['role' => 'assistant', 'content' => $reply];
        session(['chat_history' => $history]);
        return response()->json(['reply' => $reply]);
    }
}

# Côté serveur uniquement (sans NEXT_PUBLIC_)
BAKELI_AI_URL=https://ai.bakeli.tech
BAKELI_AI_KEY=ta-cle-api

import { NextRequest, NextResponse } from 'next/server';

export async function POST(req: NextRequest) {
  const body = await req.json();
  const resp = await fetch(`${process.env.BAKELI_AI_URL}/v1/chat`, {
    method: 'POST',
    headers: {
      'Content-Type':  'application/json',
      'Authorization': `Bearer ${process.env.BAKELI_AI_KEY}`,
    },
    body: JSON.stringify(body),
  });
  return NextResponse.json(await resp.json());
}

import { useState, useCallback } from 'react';

type Message = { role: 'user' | 'assistant'; content: string };

export function useAI(model = 'openai/gpt-oss-20b') {
  const [loading, setLoading]   = useState(false);
  const [messages, setMessages] = useState<Message[]>([]);

  const ask = useCallback(async (userMessage: string) => {
    const updated = [...messages, { role: 'user' as const, content: userMessage }];
    setMessages(updated);
    setLoading(true);
    try {
      const res  = await fetch('/api/ai', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ model, messages: updated }),
      });
      const data  = await res.json();
      const reply = data.message.content;
      setMessages(prev => [...prev, { role: 'assistant', content: reply }]);
      return reply;
    } finally { setLoading(false); }
  }, [messages, model]);

  return { ask, loading, messages, reset: () => setMessages([]) };
}

import { useState } from 'react';
import { useAI } from '@/hooks/useAI';

export default function ChatWidget() {
  const { ask, loading, messages } = useAI();
  const [input, setInput] = useState('');

  return (
    <div>
      {messages.map((m, i) => <div key={i}>{m.content}</div>)}
      <input value={input} onChange={e => setInput(e.target.value)} />
      <button onClick={() => { ask(input); setInput(''); }} disabled={loading}>
        {loading ? '...' : 'Envoyer'}
      </button>
    </div>
  );
}

import google.generativeai as genai
genai.configure(api_key="AIza...")
model = genai.GenerativeModel("gemini-pro")
text = model.generate_content("Explique Docker").text

from utils.ai_client import ask

# Option 1 : Utiliser Groq par défaut (+ fallback Gemini automatique)
text = ask([{"role": "user", "content": "Explique Docker"}])

# Option 2 : Forcer Gemini directement
text = ask([{"role": "user", "content": "Explique Docker"}], model="gemini-3-flash-preview")

GROQ_API_KEY=gsk_xxxxxxxxxxxxxxxxxxxx
GROQ_BASE_URL=https://api.groq.com/openai/v1  # optionnel

curl -X POST https://ai.bakeli.tech/v1/chat \
  -H "Authorization: Bearer <API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-oss-20b",
    "messages": [{"role": "user", "content": "Explique les LLM en 3 lignes."}]
  }'

GEMINI_API_KEY=AIzaSyxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
GEMINI_BASE_URL=https://generativelanguage.googleapis.com/v1beta/openai/
GEMINI_MODEL=gemini-3-flash-preview  # chat classique
GEMINI_FILE_MODEL=gemini-3-flash-preview  # défaut pour /chat/file
GEMINI_FALLBACK_MODEL=gemini-2.5-flash  # fallback si quota épuisé

from openai import OpenAI

client = OpenAI(
    api_key="AIzaSy...",
    base_url="https://generativelanguage.googleapis.com/v1beta/openai/"
)
response = client.chat.completions.create(
    model="gemini-3-flash-preview",
    messages=[{"role": "user", "content": "Bonjour !"}]
)
print(response.choices[0].message.content)

from google import genai

client = genai.Client(api_key="AIzaSy...")
with open("document.pdf", "rb") as f:
    file_part = genai.types.Part.from_bytes(
        data=f.read(),
        mime_type="application/pdf"
    )
    response = client.models.generate_content(
        model="gemini-3-flash-preview",
        contents=["Résume ce document", file_part]
    )
print(response.text)

curl -X POST https://ai.bakeli.tech/v1/chat \
  -H "Authorization: Bearer <API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-oss-20b",
    "messages": [{"role": "user", "content": "Explique Docker"}]
  }'

# Si Groq est en rate limit, la réponse sera :
{
  "model": "gemini-3-flash-preview",
  "message": { "role": "assistant", "content": "Docker est..." },
  "done": true,
  "fallback": true,
  "fallback_reason": "Groq rate limit"
}

# Si gemini-3-flash-preview est aussi épuisé :
{
  "model": "gemini-2.5-flash",
  "message": { "role": "assistant", "content": "Docker est..." },
  "done": true,
  "fallback": true,
  "fallback_reason": "Groq rate limit → gemini-3-flash-preview quota épuisé"
}

import requests

resp = requests.post(
    "https://ai.bakeli.tech/v1/chat",
    headers={"Authorization": "Bearer <API_KEY>"},
    json={
        "model": "gemini-3-flash-preview",  # ← force Gemini
        "messages": [
            {"role": "user", "content": "Explique les LLM en 3 lignes"}
        ]
    },
    timeout=60
)
print(resp.json()["message"]["content"])

# Si gemini-3-flash-preview est épuisé, bascule automatiquement sur gemini-2.5-flash

curl -X POST https://ai.bakeli.tech/v1/chat/file \
  -H "Authorization: Bearer <API_KEY>" \
  -F "prompt=Décris cette image en détail" \
  -F "file=@image.jpg"
# Pas besoin de spécifier model= → Gemini par défaut

import requests

with open("rapport.pdf", "rb") as f:
    resp = requests.post(
        "https://ai.bakeli.tech/v1/chat/file",
        headers={"Authorization": "Bearer <API_KEY>"},
        data={"prompt": "Résume ce document en 5 points"},
        files={"file": f},
        timeout=180
    )
print(resp.json()["message"]["content"])

# /v1/chat (texte)
Groq (openai/gpt-oss-20b) → Gemini-3 → Gemini-2.5 → Ollama (llama3.2)

# /v1/chat/file (fichiers)
Gemini-3 (gemini-3-flash-preview) → Gemini-2.5 (gemini-2.5-flash) → Ollama
  ├─ Images : llava-phi3
  └─ Documents : llama3.2

# Chat texte (/v1/chat)
1. Groq (openai/gpt-oss-20b) — défaut
2. Gemini-3 (gemini-3-flash-preview) — si Groq 429 ou down
3. Gemini-2.5 (gemini-2.5-flash) — si Gemini-3 429 ou down
4. Ollama (llama3.2) — si tous les quotas épuisés

# Fichiers (/v1/chat/file)
1. Gemini-3 (gemini-3-flash-preview) — défaut
2. Gemini-2.5 (gemini-2.5-flash) — si Gemini-3 429 ou down
3. Ollama — si tous les quotas épuisés
   ├─ llava-phi3 (images)
   └─ llama3.2 (documents)

curl https://ai.bakeli.tech/v1/health
docker logs -f ai-RedTeam
docker ps | grep -E "ollama|ai-RedTeam"