Vérification du service…· API compatible OpenAI

Sans clé. Tous fichiers. Zéro facture.

AIF est l'IA gratuite de BRIMIND : texte (résumer, extraire, traduire, rédiger un brouillon), fichiers (photo, note vocale, vidéo, PDF, Word, Excel ≤ 100 Mo), recherche web et voix (MP3 français, arabe, anglais), derrière une seule adresse compatible OpenAI, sans clé API ni inscription. Ce que vous branchez sur OpenAI se branche ici en changeant deux lignes.

Essayer dans le chat Premier appel en 30 s Modèles testés

Base URLhttps://aif.offer.brimind.pro/v1

Clé API · quotaaucune · sans limite

Modèle par défautauto

01 — DémarrerPremier appel

Quatre routes (texte, fichiers, recherche, voix), toutes en POST avec un corps JSON. Aucune clé n'est nécessaire : copiez une commande, elle marche. Et aucune limite de requêtes par minute ou par jour. Pas envie de coder ? Ouvrez le chat.

# texte → texte
curl https://aif.offer.brimind.pro/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model":"auto","messages":[{"role":"user","content":"Résume en 2 lignes : …"}]}'

# recherche web
curl https://aif.offer.brimind.pro/v1/search \
  -H "Content-Type: application/json" \
  -d '{"query":"pâtisserie Sousse","max_results":5}'

# texte → voix (MP3)
curl https://aif.offer.brimind.pro/v1/audio/speech \
  -H "Content-Type: application/json" \
  -d '{"input":"Votre site est prêt.","voice":"fr"}' -o message.mp3

# pip install openai — le SDK officiel marche tel quel
from openai import OpenAI
client = OpenAI(base_url="https://aif.offer.brimind.pro/v1", api_key="none")  # le SDK exige une valeur ; sans clé aif_, n'importe laquelle

r = client.chat.completions.create(
    model="smart",                       # auto | fast | smart | un id de la table
    messages=[{"role": "system", "content": "Tu réponds en français, en 3 puces."},
              {"role": "user", "content": "Pourquoi un site aide une pâtisserie ?"}],
    max_tokens=400,
)
print(r.choices[0].message.content, r.model)   # r.model = le modèle qui a vraiment répondu

const r = await fetch("https://aif.offer.brimind.pro/v1/chat/completions", {
  method: "POST",
  headers: { "Content-Type": "application/json" },   // pas de clé
  body: JSON.stringify({
    model: "fast",
    response_format: { type: "json_object" },       // réponse = JSON garanti ou erreur
    messages: [{ role: "user", content: "Extrais {nom, ville} de : Boulangerie El Amen, Sfax" }],
  }),
});
const data = await r.json();
console.log(JSON.parse(data.choices[0].message.content), r.headers.get("X-AIF-Model"));

# Tout outil qui accepte « OpenAI compatible » (n8n, Make, LibreChat, Open WebUI, Zapier Webhooks…)
Base URL : https://aif.offer.brimind.pro/v1
API key  : none          # champ obligatoire dans certains outils : mettez n'importe quoi
Model    : auto          # ou fast / smart / glm-5.2 / nemotron-3-120b …

# Ne pas activer : « tools / function calling », « vision », « embeddings » — non disponibles ici.

02 — Les trois portesCe qui entre, ce qui sort

Chaque route, avec son entrée, sa sortie et ses bornes.

POST /v1/chat/completions

Texte → texte

Entrée : messages (system / user / assistant), model, option response_format, max_tokens, stream.
Sortie : format OpenAI standard ; model dit qui a répondu. En-têtes X-AIF-Model et X-AIF-Ms.

POST /v1/search

Requête → résultats web

Entrée : query, max_results (1–10, défaut 5).
Sortie : {query, results:[{title, url, snippet}]}. Sources : DuckDuckGo, puis Brave Search en repli ; résultats gardés 1 h. Moteurs gratuits : en cas de saturation, 503 search_unavailable pendant ~10 min. Idéal pour trouver la page Facebook, Instagram ou le site d'une entreprise.

POST /v1/files

Fichier → lu pour le modèle

Entrée : n'importe quel fichier ≤ 100 Mo (corps brut + ?filename=, ou multipart champ file).
Sortie : {id, kind, text_chars, image_urls, duration, pages}. L'id se met dans un message chat. Détails : section Fichiers.

POST /v1/audio/speech

Texte → voix MP3

Entrée : input (≤ 1000 caractères), voice = code langue (fr, ar, en, es, de, it…).
Sortie : audio/mpeg, 24 kHz mono. ~0,4 s pour une phrase.

02b — Fichiers et médiasTout ce qui entre, jusqu'à 100 Mo

Aucun modèle gratuit n'entend un son, ne regarde une vidéo ni n'ouvre un PDF. AIF les convertit donc sur son serveur, puis donne au modèle ce qu'il sait lire : du texte, et des images pour les 4 modèles qui voient (gemma-4-26b, qwen3.8-27b, mistral-small-3.1, llama-4-scout). Un modèle qui ne voit pas reçoit la description de l'image, écrite par un modèle qui voit. Fichiers et extraits gardés 24 h, puis effacés ; l'original n'est jamais publié.

Type	Formats	Ce que fait AIF	Ce que le modèle reçoit	Temps
Image	jpg, png, webp, gif, heic, avif, bmp, tiff	Convertie en JPEG ≤ 1 600 px	L'image (modèles qui voient) ou sa description détaillée, texte lisible compris	< 1 s
Audio	mp3, wav, ogg, opus, m4a, aac, flac, amr, notes vocales WhatsApp	Transcription (whisper, sur notre serveur, langue détectée)	Le texte parlé	≈ 2 s par seconde d'audio
Vidéo	mp4, mov, webm, mkv, avi, 3gp	Jusqu'à 6 images clés + transcription du son	Les images + ce qui est dit	≈ 2 s par seconde de son
PDF	pdf	Texte extrait ; un scan (sans texte) → pages en images	Le texte, ou les pages (6 max) comme images	< 2 s
Office	docx, doc, odt, rtf, pptx, ppt, odp	Converti en PDF (LibreOffice), puis lu	Le texte	2–10 s
Tableur	xlsx, xls, ods	Première feuille en CSV	Le tableau en texte	2–5 s
Texte	txt, md, csv, json, xml, html, srt, vtt, eml	Lu tel quel (HTML nettoyé)	Le texte	instantané

Limites. 100 Mo par fichier · 60 000 caractères lus par fichier (au-delà : tronqué, signalé) · la question reste limitée à 6 000 caractères, mais les pièces jointes non · les fichiers de code sont refusés.

# 1. envoyer le fichier (corps brut) : AIF le lit tout de suite (transcription, texte, images)
curl "https://aif.offer.brimind.pro/v1/files?filename=note.ogg" --data-binary @note.ogg
# → {"id":"file_9f…","kind":"audio","duration":42,"text_chars":610,"preview":"Bonjour, je voudrais…"}

# 2. poser la question en citant le fichier
curl https://aif.offer.brimind.pro/v1/chat/completions -H "Content-Type: application/json" -d '{
  "model": "auto",
  "messages": [{"role": "user", "content": [
    {"type": "text", "text": "Que demande ce client ? Réponds en 2 lignes."},
    {"type": "file", "file": {"file_id": "file_9f…"}}
  ]}]}'

# Le format OpenAI marche tel quel : image par URL ou en data URL (base64)
curl https://aif.offer.brimind.pro/v1/chat/completions -H "Content-Type: application/json" -d '{
  "model": "auto",
  "messages": [{"role": "user", "content": [
    {"type": "text", "text": "Lis cette facture : fournisseur, date, total."},
    {"type": "image_url", "image_url": {"url": "https://exemple.com/facture.jpg"}}
  ]}]}'
# ⟦auto⟧ + image → un modèle qui voit (gemma-4-26b, puis qwen3.8-27b, mistral-small-3.1, llama-4-scout)
# Aussi accepté : {"type":"input_audio","input_audio":{"data":"<base64>","format":"mp3"}}
#                 {"type":"file","file":{"file_data":"data:application/pdf;base64,…","filename":"devis.pdf"}}

import requests
from openai import OpenAI

f = requests.post("https://aif.offer.brimind.pro/v1/files", files={"file": open("devis.pdf", "rb")}).json()
print(f["kind"], f["text_chars"])            # pdf 1840

client = OpenAI(base_url="https://aif.offer.brimind.pro/v1", api_key="none")
r = client.chat.completions.create(model="auto", messages=[{"role": "user", "content": [
    {"type": "text", "text": "Total TTC et date d'échéance ?"},
    {"type": "file", "file": {"file_id": f["id"]}},
]}])
print(r.choices[0].message.content)

03 — Situations détailléesQuel réglage pour quel besoin

Chaque situation donne la route, le modèle, les variables à fixer, et le piège à éviter.

Résumer une fiche, un avis, une page

Beaucoup de texte en entrée, trois lignes en sortie.

Route : chat · modèle : fast (≈ 9 s)
Variables : max_tokens: 300, un message system qui fixe le format (« 3 puces, français »).
Piège : le dernier message est limité à 6 000 caractères (limite des modèles gratuits) — coupez une page longue en morceaux, résumez chaque morceau, puis résumez les résumés.

{"model":"fast","max_tokens":300,"messages":[
 {"role":"system","content":"3 puces, français, sans introduction."},
 {"role":"user","content":"<texte de la page>"}]}

Extraire des données structurées

Un message libre devient un objet propre à ranger dans une base.

Route : chat · modèle : smart · variable clé : response_format: {"type":"json_object"}
La réponse est du JSON valide, sinon la chaîne passe au modèle suivant ; si aucun n'y arrive → 502.
Données personnelles : numéros et e-mails sont masqués avant de partir ([TEL1], [MAIL1]) puis remis dans la réponse. Vous les recevez intacts.

{"model":"smart","response_format":{"type":"json_object"},"messages":[
 {"role":"user","content":"Extrais business, city, phone : Boulangerie El Amen à Sfax, 22 111 333"}]}
  # → {"business":"Boulangerie El Amen","city":"Sfax","phone":"22 111 333"}

Traduire ou reformuler FR · EN · AR

Brouillons internes, reformulations, traductions de travail.

Modèle : nemotron-3-120b — le meilleur arabe du test, et le plus rapide.
Piège : aucun modèle n'écrit un darija tunisien fiable. Tout texte arabe destiné à un client se relit par un humain.

Trouver une entreprise sur le web

Recherche, puis synthèse : deux appels.

1. /v1/search avec "query":"<nom> <ville>", max_results: 8.
2. chat fast avec les results collés dans le message : « quelle URL est leur page officielle ? ».
Piège : les extraits sont courts ; le modèle ne lit pas les pages elles-mêmes.
Le chat fait ces deux appels pour vous avec l'option « Recherche web ».

Message vocal (WhatsApp, démo, standard)

Une phrase écrite devient un MP3 prêt à envoyer.

Route : speech · variables : voice: "fr" ou "ar", input ≤ 1000 caractères.
Voix de synthèse standard (une seule par langue), pas de clonage.

{"input":"Bonjour, votre site de démonstration est en ligne.","voice":"fr"}

Classer ou trier une liste

Leads, avis, tickets : une étiquette par ligne.

Modèle : smart · temperature: 0 pour des réponses stables · response_format JSON.
Envoyez des lots de 20 à 50 lignes plutôt qu'une requête par ligne : moins d'attente au total, et une étiquette cohérente d'une ligne à l'autre.

Interface de chat en direct

Pour un widget ou un outil qui attend un flux SSE.

stream: true est accepté : le texte arrive en un seul bloc SSE, puis [DONE]. Compatible avec les clients OpenAI ; l'effet « mot à mot » n'existe pas.
Prévoir un indicateur d'attente : 9 à 50 s selon le modèle.
Exemple complet : notre chat, construit uniquement sur cette API.

Hors périmètre, refusé par le serveur — pas une recommandation, une règle :

ProgrammationÉcrire, corriger ou expliquer du code → 403 coding_refused.

Appels d'outilstools / functions → 400 tools_unsupported.

Fichiers de code.js, .py, .php… → 403 coding_refused.

Générer des images, embeddingsAucun modèle gratuit ne le fait ici : pas de route.

Texte final à un clientAutorisé techniquement, mais toujours relu : la qualité varie d'un modèle à l'autre.

04 — Variables pivotsLes boutons qui changent le résultat

Tout ce que vous pouvez régler, sa valeur par défaut, et quand y toucher.

Variable	Route	Valeurs	Défaut	Quand la changer
`model`	chat	`auto` · `fast` · `smart` · un id de la table	`auto`	`fast` pour la vitesse, `smart` pour le raisonnement, un id pour un résultat reproductible (pas de repli).
`messages[].role`	chat	`system` · `user` · `assistant`	—	`system` fixe la langue, le ton, le format. `assistant` sert à rejouer un historique.
`messages[].content`	chat	texte, ou liste de parts : `text`, `image_url`, `input_audio`, `file`	—	La question (texte du dernier message user) : 6 000 caractères au plus, sinon `413 prompt_too_long`. Les fichiers joints ne comptent pas : jusqu'à 100 Mo chacun (voir Fichiers).
`messages[].role = system`	chat	texte	—	La consigne permanente (langue, ton, format). Respectée par les modèles marqués Consigne dans la table.
`max_tokens`	chat	—	—	Accepté mais sans effet : les modèles gratuits décident de la longueur. Demandez-la dans la consigne (« en 3 lignes »).
`temperature`	chat	0 – 2	celle du modèle	`0` pour classer et extraire. Tous les modèles ne la respectent pas.
`response_format`	chat	`{"type":"json_object"}`	texte libre	Dès qu’un programme lit la réponse.
`stream`	chat	`true` · `false`	`false`	Seulement si votre client exige du SSE.
`query`	search	texte	—	Nom + ville trouve mieux qu’une description.
`max_results`	search	1 – 10	5	Montez à 8–10 pour trouver une page précise.
`input`	speech	≤ 1000 caractères	—	Coupez un long texte en phrases.
`voice`	speech	code langue ISO : `fr`, `ar`, `en`…	`fr`	La langue du texte, pas un timbre de voix.
`Authorization`	toutes (POST) — facultatif	`Bearer aif_…` ou en-tête `X-API-Key`	aucune	Inutile : ni clé ni quota. Une clé `aif_…` sert seulement à nommer l'appelant dans nos statistiques ; toute autre valeur est ignorée.

Arbitrage vitesse / qualité. fast ≈ 8 s, smart ≈ 12 s, vision (images) ≈ 10–15 s. auto commence par le plus rapide et ne descend la chaîne qu'en cas d'échec. Le modèle qui a vraiment répondu est dans model et dans l'en-tête X-AIF-Model.

05 — ModèlesTous les modèles, testés

Modèles réellement servis aujourd'hui (liste vérifiée en direct le 23/09/2026 : chaque réponse est contrôlée, le modèle demandé est bien celui qui répond). ok = fiable · weak = répond, mais échoue à la plupart des tests · down = en panne côté fournisseur. Version machine : GET /v1/models.

Image le modèle voit l'image lui-mêmeImage AIF la lui décrit en texte (via un modèle qui voit)AudioVidéoPDFOffice AIF les convertit pour tous : transcription, images clés, texte extrait

Modèle	État	Entrée	Sortie	Contexte	Temps	Remarque
`deepseek-v4-pro`	ok	TexteImageAudioVidéoPDFOffice	TexteJSONArabeConsigne	128 k	≈ 4 s	Strongest coder on the Playground; the tool-calling default (OpenCode)
`kimi-k2.7-code`	ok	TexteImageAudioVidéoPDFOffice	TexteJSONArabeConsigne	128 k	≈ 6 s	Coding model
`glm-5.2`	ok	TexteImageAudioVidéoPDFOffice	TexteJSONArabeConsigne	128 k	≈ 4 s	Large reasoning model
`nemotron-3-120b`	ok	TexteImageAudioVidéoPDFOffice	TexteJSONArabeConsigne	256 k	≈ 8 s	Fastest of the best; best derja of the lot
`gpt-oss-120b`	ok	TexteImageAudioVidéoPDFOffice	TexteJSONArabeConsigne	128 k	≈ 12 s	Strong reasoning; slow on Arabic (35 s)
`gemma-4-26b`	ok	TexteImageAudioVidéoPDFOffice	TexteJSONArabeConsigne	256 k	≈ 13 s	Sees images; the best all-rounder with a photo (reads signs and logos)
`glm-4.7-flash`	ok	TexteImageAudioVidéoPDFOffice	TexteJSONArabeConsigne	131 k	≈ 13 s	Reasoning model; the Playground's default
`qwen3.8-27b`	ok	TexteImageAudioVidéoPDFOffice	TexteJSONArabeConsigne	262 k	≈ 10 s	Sees images; ignored the system prompt in the test
`mistral-small-3.1`	ok	TexteImageAudioVidéoPDFOffice	TexteJSONArabeConsigne	128 k	≈ 6 s	Sees images; fast. Streams every word twice — AIF repairs it
`llama-4-scout`	ok	TexteImageAudioVidéoPDFOffice	TexteJSONArabeConsigne	131 k	≈ 7 s	Sees images. Streams every word twice — AIF repairs it
`granite-4.0-micro`	ok	TexteImageAudioVidéoPDFOffice	TexteJSONArabeConsigne	131 k	≈ 7 s	Tiny and quick; failed JSON extraction
`qwen2.5-32b`	ok	TexteImageAudioVidéoPDFOffice	TexteJSONArabeConsigne	33 k	≈ 8 s	Short answers; failed the word problem
`gpt-oss-20b`	weak	TexteImageAudioVidéoPDFOffice	TexteJSONArabeConsigne	128 k	≈ 5 s	Fast, but empty answers on the reasoning questions
`qwen3-30b`	weak	TexteImageAudioVidéoPDFOffice	TexteJSONArabeConsigne	33 k	≈ 9 s	Mostly wrong or empty
`llama-3.2-3b`	weak	TexteImageAudioVidéoPDFOffice	TexteJSONArabeConsigne	80 k	≈ 7 s	Very small model
`deepseek-r1-distill-32b`	weak	TexteImageAudioVidéoPDFOffice	TexteJSONArabeConsigne	80 k	≈ 12 s	Rambles, rarely concludes
`qwq-32b`	weak	TexteImageAudioVidéoPDFOffice	TexteJSONArabeConsigne	24 k	≈ 11 s	Thinks aloud in English, never concludes
`llama-3.1-8b`	down	—	—	32 k	—	Answers only with made-up tool calls
`llama-3.3-70b`	down	—	—	24 k	—	Empty answers since it needs the tool server
`sea-lion-v4-27b`	down	—	—	128 k	—	Internal server error on every call
`llama-3.2-11b-vision`	down	—	—	128 k	—	Needs a licence 'agree' step the Playground refuses

Sortie : JSON a rendu un JSON valide au test · Arabe a traduit correctement en arabe · Consigne a obéi au message system · barré = a échoué. Contexte = quantité de texte que le modèle peut lire en une fois (1 k tokens ≈ 4 000 caractères) : pièces jointes et historique compris. Tous les modèles répondent en texte, jusqu'à ~4 000 tokens.

Recherche et voix : entrées et sorties

Ce ne sont pas des modèles de langage, mais ils ont aussi leur entrée et leur sortie.

Moteur	Route	Entrée	Sortie
DuckDuckGo, puis Brave Search	`/v1/search`	Une requête texte ≤ 400 caractères, `max_results` 1–10	Jusqu'à 10 résultats `{title, url, snippet}` ; pas le contenu des pages
Google Traduction (synthèse vocale)	`/v1/audio/speech`	Texte ≤ 1 000 caractères + code langue (`fr`, `ar`, `en`…)	MP3 (`audio/mpeg`), 24 kHz mono, une voix standard par langue

Alias : chaînes de repli

Un alias essaie chaque modèle dans l'ordre jusqu'à ce qu'un réponde.

Alias	Ordre d'essai
`auto`	`nemotron-3-120b` → `gpt-oss-120b` → `glm-4.7-flash` → `gemma-4-26b` → `qwen3.8-27b`
`fast`	`nemotron-3-120b` → `mistral-small-3.1` → `granite-4.0-micro`
`smart`	`gpt-oss-120b` → `gemma-4-26b` → `nemotron-3-120b` → `glm-4.7-flash`
`code`	`kimi-k2.7-code` → `glm-5.2` → `nemotron-3-120b`
`vision`	`gemma-4-26b` → `qwen3.8-27b` → `mistral-small-3.1` → `llama-4-scout`

06 — Erreurs et limitesLire le code, pas le message

Toutes les erreurs ont la forme {"error":{"type","message"}}.

Code	type	Cause	Que faire
400	`bad_request` · `model_not_found` · `tools_unsupported`	Corps invalide, modèle inconnu ou en panne, `tools` envoyé.	Corriger la requête ; voir `/v1/models`.
401	`invalid_api_key`	Clé `aif_…` inconnue ou révoquée (sans clé, jamais de 401).	Retirer l’en-tête, ou vérifier la clé.
403	`coding_refused`	La demande porte sur du code.	Ce service n’en fait pas.
413	`prompt_too_long` · `file_too_large`	Question au-delà de 6 000 caractères (limite des modèles gratuits) ; ou fichier au-delà de 100 Mo.	Mettre le long texte dans un fichier joint ; couper le fichier.
404	`file_not_found`	Un `file_id` inconnu ou expiré (fichiers gardés 24 h).	Renvoyer le fichier.
415	`unsupported_file`	Type de fichier non pris en charge ; la liste est dans `supported`.	Convertir en PDF, image ou texte.
422	`unreadable_file`	Fichier corrompu, protégé, ou sans rien de lisible (ni texte, ni image, ni parole).	Vérifier le fichier.
502	`upstream_failed`	Tous les modèles de la chaîne ont échoué ; le détail est dans `tried`.	Réessayer dans une minute ou changer de modèle.
503	`busy`	Plus de 100 requêtes en file d’attente (4 traitées en même temps, pour ne pas faire tomber les modèles gratuits). Ce n’est pas un quota.	Réessayer après quelques secondes.
503	`search_unavailable`	Recherche web : les moteurs gratuits nous limitent ; le détail est dans `tried`.	Réessayer dans ~10 minutes.

Disponibilité. Le service tourne en continu et se relance seul après une panne ou un redémarrage. Il est vérifié toutes les heures. Les modèles viennent de fournisseurs gratuits tiers sans garantie de service : un modèle peut disparaître sans préavis, d'où les chaînes de repli. État en direct : GET /health.

Rien à demander, c'est branché.

L'API marche sans clé et sans limite, et le chat aussi. Besoin de l'IA intégrée à votre site, votre caisse ou votre suivi client ? Écrivez-nous sur WhatsApp.

Ouvrir le chat WhatsApp API · +1 711-769-2295 WhatsApp mobile · +216 26 985 698 Appels / SMS · +216 26 985 698