Prologue : Le Point de Non-Retour

Février 2026. Mon bureau ressemble à un vaisseau spatial en panne : câbles entrelacés, trois écrans qui clignotent, une tour qui ronfle comme un réacteur nucléaire. Sur mon relevé bancaire, une ligne me hante chaque mois : 20€ pour Cursor, 40€ pour ChatGPT Plus, 30€ pour Midjourney. Près de 100 balles par mois pour louer de l'intelligence artificielle que je ne contrôle pas, qui analyse mon code, qui garde mes données.

La question m'obsède : pourquoi louer quand on peut construire ? J'ai 24 Go de VRAM qui tournent au ralenti, un processeur qui s'ennuie, et cette rage viscérale contre la dépendance aux géants de la tech. Ce texte raconte ma guerre sale mais victorieuse pour reprendre le contrôle. Spoiler : j'ai gagné, mais pas comme prévu.

Partie I : L'Enfer du Local Pur

Le Mensonge Continue.dev

"VS Code + Continue.dev = Cursor gratuit !" hurlent les threads Reddit avec des milliers d'upvotes. Je plonge tête la première, convaincu d'avoir trouvé le Saint Graal. Dix heures plus tard, je fixe mon écran avec l'envie de tout balancer par la fenêtre.

Le verdict brutal :

• L'indexation du codebase ? Une blague. Continue.dev ne comprend rien à l'architecture de mon projet Flutter/Python.
• Les suggestions ? Des hallucinations dignes d'un mauvais trip sous LSD. Il me propose du code Java pour du Dart, invente des librairies qui n'existent pas.
• Le tool-calling ? Un carnage total. Impossible de lui faire exécuter des commandes shell ou d'accéder à mes fichiers proprement.

J'ai crashé, réinstallé, lu 47 threads GitHub. Conclusion : Continue.dev fonctionne pour un "Hello World", pas pour un vrai projet en production. Retour à la case départ.

La Stack Locale qui Survit (Mais qui Saigne)

Après des nuits blanches alimentées au café froid et à la rage pure, j'arrive à un setup qui tient debout :

Architecture de base :

• IDE : VSCodium (VS Code sans la télémétrie Microsoft qui espionne chaque frappe)
• Extension : Roo Code (la seule qui gère l'indexation vectorielle sérieuse avec RAG)
• Modèle :mychen76/qwen3_cline_roocode via Ollama (solide en tool-calling)
• Base vectorielle : Qdrant en Docker pour le RAG

Lancement de la stack :

# Démarrage de Qdrant pour l'indexation vectorielle
docker run -p 6333:6333 -p 6334:6334 \
  -v "$(pwd)/qdrant_storage:/qdrant/storage:z" \
  qdrant/qdrant

# Dashboard accessible sur http://localhost:6333/dashboard

Ça marche. Mais à quel prix.

Les problèmes qui persistent :

1. Le context window sature à 128k tokens en pratique (loin des 256k annoncés)
2. Ollama gère catastrophiquement le KV Cache – l'IA passe son temps à résumer son propre contexte
3. La latence explose sur des requêtes complexes multi-fichiers
4. Les suggestions arrivent avec 2-3 secondes de retard, brisant totalement le flow de dev

Solution en cours de test : Remplacer Ollama par ExLlamaV2 pour un gain de 50-100% de vitesse (90-140 tokens/s sur des modèles 32B quantifiés Q5). Mais le KV Cache reste le boss final.

Le KV Cache : Le Boss Final de l'IA Locale

Le Key-Value Cache stocke les états intermédiaires du modèle pendant l'inférence. Sur des projets complexes avec des milliers de lignes de code, il explose littéralement la VRAM et ralentit tout.

Benchmark des solutions d'optimisation (2026) :

Commande pour activer FP8 dans vLLM :

python -m vllm.entrypoints.api_server \
    --model mychen76/qwen3_cline_roocode \
    --quantization fp8 \
    --gpu-memory-utilization 0.9 \
    --max-model-len 32768

Le local pur, c'est puissant pour la souveraineté. Mais pour la productivité pure ? Il me fallait autre chose.

Partie II : La Révélation OpenRouter

Le Moment Pivot

Un soir de février 2026, en scrollant des benchmarks sur un forum obscur, je tombe sur OpenRouter. Un routeur unifié vers 300+ modèles LLM avec une API compatible OpenAI. Je peux switcher entre OpenAI, Anthropic, Meta, Mistral... sans réécrire une ligne de code.

Le vrai game-changer ? Les modèles gratuits open-source qui rivalisent avec Claude 3.5 Sonnet pour le coding.

Pourquoi OpenRouter Enterre Cursor

Cursor : Une boîte noire. Tu ne sais pas quel prompt système ils utilisent, quelles données ils gardent, quel modèle tourne réellement. 20€/mois sans transparence.

OpenRouter : Transparence totale. Je choisis mon modèle, je vois mon usage, je contrôle mes coûts. Et les free tiers sont monstrueux.

Les modèles gratuits qui déchirent (2026) :

Estimation coût mensuel : 0-2€ pour 10k requêtes/jour (vs 20€ Cursor, 100€ Claude)

L'Intégration : Code qui Parle

Backend Python avec FastAPI :

# requirements: fastapi, openai
from fastapi import FastAPI
from openai import OpenAI
import os

app = FastAPI()
client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key=os.getenv("OPENROUTER_API_KEY"),
)

@app.post("/code-assist")
async def code_assist(prompt: str):
    response = client.chat.completions.create(
        model="mistralai/devstral-2-2512:free",  # Gratuit, top coding
        messages=[{"role": "user", "content": f"Flutter/Python: {prompt}"}],
        max_tokens=4000
    )
    return {"code": response.choices[0].message.content}

Frontend Flutter :

// pubspec.yaml: openrouter_api: ^latest
import 'package:openrouter_api/openrouter_api.dart';

class CodeAssistant extends StatefulWidget {
  @override
  _CodeAssistantState createState() => _CodeAssistantState();
}

class _CodeAssistantState extends State<CodeAssistant> {
  final client = OpenRouter.inference(key: "sk-or-...");
  
  Future<String> generateCode(String prompt) async {
    final response = await client.getCompletion(
      modelId: "mistralai/devstral-2-2512:free",
      messages: [LlmMessage.user(content: "Génère Flutter widget: $prompt")],
    );
    return response.choices.first.content;
  }
}

Route auto-gratuite (recommandée) :

# Utilise automatiquement le meilleur modèle gratuit disponible
model="openrouter/free"

Partie III : L'Architecture Astroport – Le Hub GPU Souverain

Le Multipass : Mon Passe-Partout vers la Liberté

J'ai monté mon propre nœud via Astroport.ONE (github.com/papiche/Astroport.ONE/tree/master/IA). Mon PC n'est plus un ordinateur, c'est un relai satellite dans une constellation décentralisée.

Workflow magique avec #BRO :

1. Orchestrateur : Gemma 3 (via gemma3-tools) analyse ma demande et décompose les tâches
2. Recherche : Perplexica s'active en local, scan le web, extrait la vérité, vire la pub
3. Rédaction : Gemma 3 synthétise et rédige l'article complet
4. Publication : Direct sur Use.Nostr (write.nostr.com) – incensurable, décentralisé

# Exemple de commande
#BRO #search "optimisation KV Cache 2026"
# → Recherche + Rédaction + Publication automatique

Setup Créatif : Le Beau, le Brut et la Vidéo

Images : ComfyUI tourne en arrière-plan. Gemma 3 génère les prompts, ComfyUI crache des visuels cyberpunk professionnels. Stable, rapide, gratuit.

Vidéo (le débat honnête) :

• Wan2.1 (local) : Parfait pour des boucles d'ambiance, illustrations abstraites, tests rapides. Image-to-video en 640x640, stable, 0€.
• Veo3/Sora (API externe) : Pour du cinématique ultra-propre client-ready, la cohérence temporelle reste supérieure. Usage ponctuel.

Ma règle : Local pour l'itération, cloud ponctuel pour la perfection. L'hybride, c'est savoir choisir ses batailles.

Partie IV : Le Bilan – David Écrase Goliath

Comparatif Financier Brutal (2026)

Sans compter : électricité (~20€/mois sur GPU en charge), mais matériel amorti en 6 mois.

Comparatif Performances Techniques

Solutions de Génération Vidéo :

Solutions de Coding Assisté :

Conclusion : On Ne Loue Plus l'Intelligence, On la Mixe

Février 2026 marque un tournant. L'IA n'est plus un service qu'on loue, c'est une infrastructure qu'on compose.

Ce que j'ai appris :

• ✅ Le local pur est idéal pour la souveraineté, les données sensibles, l'expérimentation
• ✅ OpenRouter gratuit offre 90% de la puissance de Claude pour 0€
• ✅ L'hybride combine le meilleur des deux mondes sans compromis
• ✅ Astroport transforme ton PC en nœud d'une constellation décentralisée
• ✅ Nostr rend tes écrits incensurables, tes clés sont ton identité

Mon setup final :

• Coding : VSCodium + Roo Code + OpenRouter (Devstral 2 free → MiniMax si besoin)
• Recherche : Perplexica local + Gemma 3 orchestration
• Création : ComfyUI images + Wan2.1 vidéo local + Veo3 ponctuel
• Publication : Nostr (write.nostr.com)
• Identité : Clés crypto, pas de Google/Facebook
• Coût : ~9€/mois vs 160€/mois avant

Le manifeste :

1. Coupe le cordon des abonnements
2. Monte ton HUB GPU local (même petit)
3. Hybride avec OpenRouter pour la puissance
4. Publie sur Nostr pour l'incensurabilité
5. Garde tes clés, garde ton pouvoir

Le rêve du dev 0€/mois, 100% contrôle n'est plus un fantasme. C'est un dépôt GitHub et quelques commandes Docker.

Tu as le matos. Tu as le talent. Coupe le cordon.

Sagittarius, terminé.

📧 support@qo-op.com | 💬 UPlanet : https://qo-op.com

Annexe Technique

A. Installation Complète du Stack Local

A.1 Prérequis Système

# Configuration minimale recommandée
- GPU: 12 Go VRAM minimum (RTX 3060), 24 Go optimal (RTX 4090/5090)
- RAM: 32 Go minimum, 64 Go recommandé
- Stockage: 500 Go SSD pour les modèles
- OS: Ubuntu 22.04+ ou Windows 11 avec WSL2

A.2 Installation Qdrant (Base Vectorielle)

# Via Docker (recommandé)
docker run -d \
  --name qdrant \
  -p 6333:6333 -p 6334:6334 \
  -v "$(pwd)/qdrant_storage:/qdrant/storage:z" \
  qdrant/qdrant

# Vérification
curl http://localhost:6333/health

# Dashboard
open http://localhost:6333/dashboard

A.3 Installation Ollama + Modèles

# Installation Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Téléchargement du modèle de coding
ollama pull mychen76/qwen3_cline_roocode

# Test rapide
ollama run mychen76/qwen3_cline_roocode "Write a Python function to calculate fibonacci"

A.4 Installation ExLlamaV2 (Alternative Haute Performance)

# Clone du repo
git clone https://github.com/turboderp/exllamav2
cd exllamav2

# Installation des dépendances
pip install -r requirements.txt --break-system-packages

# Téléchargement d'un modèle quantifié (exemple)
# Utiliser Hugging Face pour les modèles GPTQ/EXL2
huggingface-cli download turboderp/Qwen3-32B-Cline-EXL2 --local-dir ./models/

# Lancement du serveur
python examples/server.py \
  --model ./models/Qwen3-32B-Cline-EXL2 \
  --port 8000 \
  --max_seq_len 32768

A.5 Installation VSCodium + Roo Code

# Installation VSCodium (Linux)
wget -qO - https://gitlab.com/paulcarroty/vscodium-deb-rpm-repo/raw/master/pub.gpg \
  | gpg --dearmor \
  | sudo dd of=/usr/share/keyrings/vscodium-archive-keyring.gpg

echo 'deb [ signed-by=/usr/share/keyrings/vscodium-archive-keyring.gpg ] https://download.vscodium.com/debs vscodium main' \
  | sudo tee /etc/apt/sources.list.d/vscodium.list

sudo apt update && sudo apt install codium

# Installation extension Roo Code
codium --install-extension roo-code.roo-cline

Configuration Roo Code (settings.json) :

{
  "roo-code.apiProvider": "ollama",
  "roo-code.ollamaEndpoint": "http://localhost:11434",
  "roo-code.model": "mychen76/qwen3_cline_roocode",
  "roo-code.vectorDb": {
    "type": "qdrant",
    "endpoint": "http://localhost:6333",
    "collection": "codebase"
  },
  "roo-code.contextWindow": 128000,
  "roo-code.maxTokens": 4096
}

B. Configuration OpenRouter

B.1 Création du Compte et Clé API

# 1. Aller sur https://openrouter.ai
# 2. Se connecter (Google/GitHub)
# 3. Naviguer vers API Keys
# 4. Créer une clé avec limites (ex: 5$/mois max)
# 5. Copier la clé (sk-or-v1-...)

# Ajouter au .bashrc ou .zshrc
echo 'export OPENROUTER_API_KEY="sk-or-v1-..."' >> ~/.bashrc
source ~/.bashrc

B.2 Test Rapide avec curl

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/devstral-2-2512:free",
    "messages": [
      {"role": "user", "content": "Write a Python FastAPI hello world"}
    ]
  }'

B.3 Configuration Continue.dev avec OpenRouter

settings.json Continue :

{
  "models": [
    {
      "title": "Devstral 2 Free",
      "provider": "openrouter",
      "model": "mistralai/devstral-2-2512:free",
      "apiKey": "$OPENROUTER_API_KEY"
    },
    {
      "title": "MiniMax M2.1",
      "provider": "openrouter",
      "model": "minimax/minimax-m2-1",
      "apiKey": "$OPENROUTER_API_KEY"
    }
  ],
  "tabAutocompleteModel": {
    "title": "Devstral Tab",
    "provider": "openrouter",
    "model": "mistralai/devstral-2-2512:free"
  }
}

C. Installation Stack Astroport

C.1 Clone et Setup Initial

# Clone du repo
git clone https://github.com/papiche/Astroport.ONE.git
cd Astroport.ONE

# Installation 
./install.sh

C.2 Installation Perplexica

# Clone Perplexica
git clone https://github.com/ItzCrazyKns/Perplexica.git
cd Perplexica

# Configuration Docker
cp sample.config.toml config.toml

# Éditer config.toml pour ajouter tes API keys (optionnel)
nano config.toml

# Lancement
docker-compose up -d

# Interface accessible sur http://localhost:3000

C.3 Installation Gemma 3 Tools

# Installation via Ollama
ollama pull gemma2:27b-instruct-tools

# Test tool-calling
ollama run gemma2:27b-instruct-tools --tools "What's the weather in Paris?"

D. Optimisations Avancées

D.1 Configuration vLLM avec PagedAttention

# Installation vLLM
pip install vllm --break-system-packages

# Lancement avec quantization FP8
python -m vllm.entrypoints.openai.api_server \
  --model mychen76/qwen3_cline_roocode \
  --quantization fp8 \
  --gpu-memory-utilization 0.9 \
  --max-model-len 32768 \
  --enable-prefix-caching \
  --kv-cache-dtype fp8

D.2 Monitoring GPU avec gpustat

# Installation
pip install gpustat --break-system-packages

# Monitoring temps réel
watch -n 0.5 gpustat --color

# Sortie exemple:
# [0] NVIDIA RTX 4090 | 68°C | 22134 / 24564 MB | python (21.8GB)

E. Sécurité et Backup

E.1 Isolation Docker Network

# Créer un réseau isolé pour les services IA
docker network create ai_network

# Lancer Qdrant sur ce réseau
docker run -d \
  --name qdrant \
  --network ai_network \
  -p 6333:6333 \
  qdrant/qdrant

# Lancer Perplexica sur le même réseau
cd Perplexica
docker-compose up -d
docker network connect ai_network perplexica

E.2 Rate Limiting Local

# Installation nginx pour rate limiting
sudo apt install nginx

# Configuration /etc/nginx/sites-available/ollama
limit_req_zone $binary_remote_addr zone=ollama:10m rate=10r/s;

server {
    listen 8080;
    location / {
        limit_req zone=ollama burst=5;
        proxy_pass http://localhost:11434;
    }
}

Lexique Technique

A

Agentic Coding : Capacité d'un modèle IA à planifier et exécuter des tâches de programmation multi-étapes de manière autonome, incluant l'analyse du code existant, la génération de nouvelles fonctions et le debugging.

Anthropic : Entreprise d'IA créatrice de Claude, concurrent direct de GPT-4 d'OpenAI, spécialisée dans les modèles "constitutional AI" avec garde-fous éthiques.

API (Application Programming Interface) : Interface permettant à deux logiciels de communiquer. OpenRouter utilise une API compatible OpenAI pour faciliter la migration.

Astroport.ONE : Projet open-source de constellation de nœuds décentralisés permettant de monter son propre "satellite" avec services IA, stockage IPFS et identité Nostr.

B

Benchmark : Test standardisé mesurant les performances d'un modèle. SWE-Bench (Software Engineering Benchmark) évalue la capacité à résoudre de vrais bugs GitHub.

BRO (tag) : Convention de commande dans Astroport pour déclencher des workflows automatisés (ex: #BRO #search lance recherche + rédaction + publication).

C

Claude : Famille de modèles LLM d'Anthropic. Claude 3.5 Sonnet est particulièrement performant en coding et raisonnement.

ComfyUI : Interface graphique open-source pour Stable Diffusion, permettant de créer des workflows complexes de génération d'images via des nœuds.

Context Caching : Technique d'optimisation stockant les parties répétées d'un prompt pour réduire les coûts et la latence (jusqu'à -75% sur OpenRouter).

Context Window : Taille maximale du texte qu'un modèle peut "voir" simultanément (historique + prompt). Mesuré en tokens (ex: 128k tokens ≈ 100k mots).

Continue.dev : Extension VS Code open-source promettant un "Cursor gratuit", mais avec limitations importantes en production.

Cursor : IDE basé sur VS Code avec assistance IA intégrée, propriétaire, 20€/mois, boîte noire totale.

D

DeepSeek : Entreprise chinoise créatrice de modèles LLM open-source performants (DeepSeek V3 rivalise avec GPT-4o pour <1$/M tokens).

Devstral : Modèle de Mistral AI spécialisé en coding, disponible gratuitement sur OpenRouter (version 2512 avec 256k contexte).

Docker : Technologie de conteneurisation permettant d'isoler des applications et leurs dépendances dans des "containers" légers.

E

ExLlamaV2 : Backend d'inférence ultra-optimisé pour modèles quantifiés, 50-100% plus rapide qu'Ollama sur GPU grand public.

EXL2 / GPTQ : Formats de quantization agressifs réduisant la taille des modèles de 50-75% avec perte de qualité minimale.

F

FastAPI : Framework Python moderne pour créer des APIs REST ultra-rapides avec validation automatique des données.

FP8 (Float Point 8-bit) : Format numérique réduit utilisant 8 bits au lieu de 16/32, divisant par 2-4 la mémoire requise pour le KV Cache.

Flutter : Framework Google pour créer des apps multi-plateformes (iOS, Android, Web) avec un seul codebase Dart.

G

Gemini : Famille de modèles Google, Gemini 3 Flash offre 1M+ tokens de contexte mais moins performant en coding pur que les spécialisés.

Gemma : Modèles open-source de Google, Gemma 3 27B excelle en tool-calling et orchestration d'agents.

GPU (Graphics Processing Unit) : Processeur spécialisé initialement pour le graphisme, désormais essentiel pour l'IA (parallélisation massive).

H

Hugging Face : Plateforme open-source hébergeant des milliers de modèles IA téléchargeables gratuitement.

I

Inférence : Processus d'utilisation d'un modèle IA pour générer des prédictions/réponses (opposé à "entraînement").

IPFS (InterPlanetary File System) : Protocole de stockage décentralisé pair-à-pair, les fichiers sont identifiés par leur contenu (hash) plutôt qu'un serveur.

K

KV Cache (Key-Value Cache) : Structure stockant les états intermédiaires d'un transformer lors de l'inférence, critique pour la vitesse mais gourmand en VRAM.

KVSwap : Technique académique (2025) échangeant dynamiquement le KV Cache entre disque et GPU pour gérer des contextes géants.

L

LLM (Large Language Model) : Modèle de langage de grande taille (GPT, Claude, Llama...) entraîné sur des milliards de textes.

LMCache : Système de cache distribué pour KV Cache, permettant de partager les états entre requêtes et utilisateurs.

M

Midjourney : Service propriétaire cloud de génération d'images, ~30€/mois, qualité artistique élevée mais zéro contrôle.

MiniMax : Entreprise chinoise créatrice de modèles multimodaux, M2.1 offre un excellent rapport qualité/prix (0,28$/M tokens).

Mistral AI : Startup française créatrice de modèles open-source performants (Mistral, Mixtral, Devstral).

N

Nostr (Notes and Other Stuff Transmitted by Relays) : Protocole décentralisé de publication reposant sur des clés cryptographiques (pas de serveur central, incensurable).

npub / nsec : Clés publique/privée Nostr (npub = identité visible, nsec = clé privée à protéger absolument).

O

Ollama : Runtime local simple pour faire tourner des LLMs open-source, mais limitations sur KV Cache et performances.

OpenRouter : Service routant les requêtes vers 300+ modèles LLMs via une API unifiée, avec free tiers et transparence totale.

P

PagedAttention : Algorithme de vLLM gérant dynamiquement le KV Cache par "pages" mémoire, réduisant la fragmentation et la VRAM gaspillée.

Perplexica : Moteur de recherche IA local open-source (alternative à Perplexity), intégrable dans Astroport.

PlantNet : API/modèle d'identification botanique par image, utilisé pour la biodiversité dans UPlanet.

Prefix Caching : Réutilisation du KV Cache pour les parties répétées d'un prompt (ex: system prompt identique sur 1000 requêtes).

Q

Qdrant : Base de données vectorielle open-source pour RAG, stocke les embeddings du codebase pour recherche sémantique rapide.

Quantization : Réduction de la précision numérique des poids d'un modèle (16-bit → 8-bit → 4-bit) pour économiser mémoire et calcul.

Qwen : Famille de modèles open-source d'Alibaba, Qwen3-Coder est state-of-the-art en coding (gratuit sur OpenRouter).

R

RAG (Retrieval-Augmented Generation) : Technique combinant recherche dans une base de connaissances + génération LLM pour des réponses contextuelles précises.

Relay (Nostr) : Serveur relayant les événements Nostr, n'importe qui peut en héberger (ex: wss://relay.damus.io).

Roo Code : Extension VSCodium/VS Code gérant indexation vectorielle sérieuse + RAG pour assistance coding locale.

Runway ML : Service cloud de génération vidéo IA (Gen-4.5), 15-70€/mois, qualité élevée mais propriétaire.

S

Sora : Modèle OpenAI de génération vidéo à partir de texte, 40-100€/mois, cohérence temporelle excellente mais boîte noire.

SWE-Bench (Software Engineering Benchmark) : Test standardisé mesurant la capacité d'un LLM à résoudre de vrais bugs GitHub. Score >70% = niveau professionnel.

T

TabbyAPI : Serveur d'inférence léger pour ExLlamaV2, avec support natif du prefix caching.

Token : Unité de texte pour les LLMs (~0.75 mots en anglais). Les prix sont en $/million tokens.

Tool-calling : Capacité d'un LLM à invoquer des fonctions externes (APIs, shell, recherche...) pour accomplir des tâches complexes.

U

UPlanet : Écosystème de l'article, incluant génération vidéo Wan2.2 et identification biodiversité, intégré à Astroport.

V

Veo3 : Modèle de génération vidéo Google (successeur d'Imagen Video), cohérence temporelle de pointe.

vLLM : Backend d'inférence haute performance avec PagedAttention, idéal pour batching multi-utilisateurs et production.

VRAM (Video RAM) : Mémoire dédiée du GPU, critique pour l'IA (24 Go = modèles 30-70B quantifiés, 12 Go = modèles 7-13B).

VSCodium : VS Code sans télémétrie Microsoft, 100% open-source, binaires compilés depuis le code libre.

W

Wan2.1/2.2 : Modèles open-source de génération vidéo image-to-video, tournant localement sur GPU grand public (640x640, MoE 14B).

write.nostr.com : Interface web pour publier du contenu long-form sur Nostr (alternative décentralisée à Medium).

Z

Ẑen : Unité monétaire interne de la coopérative UPlanet (~1 Ẑen ≈ 1€), utilisée pour les services partagés.

Tags : #LocalAI #OpenRouter #Astroport #Nostr #HybridStack #DevSouverain #NoSubscription #Gemma3 #Qwen3 #CyberpunkDev