DEV Community

Cover image for Qu'est-ce qu'OpenViking ?
Antoine Laurent
Antoine Laurent

Posted on • Originally published at apidog.com

Qu'est-ce qu'OpenViking ?

#ai #database #opensource #rag

En bref

OpenViking est une base de données de contexte open-source pour les agents IA qui remplace le stockage vectoriel plat par un paradigme de système de fichiers. Il organise le contexte (mémoires, ressources, compétences) sous des URI viking:// avec trois couches : L0 (~100 tokens), L1 (~2k tokens), L2 (contenu complet). Les benchmarks montrent une réduction de 91 % du coût des tokens et une amélioration de 43 % de l'achèvement des tâches par rapport au RAG traditionnel.

Essayez Apidog dès aujourd'hui

Introduction

Votre agent IA oublie constamment des choses. Il a demandé le même point de terminaison API deux fois. Il a ignoré votre préférence d'environnement de staging. Il a perdu la trace des tests réussis hier.

C'est la réalité de la construction d'agents aujourd'hui. La plupart des équipes bricolent des pipelines RAG, des bases de données vectorielles et des systèmes de mémoire personnalisés. Le résultat : un contexte fragmenté, des coûts de tokens qui explosent et une récupération qui échoue silencieusement.

Les données le confirment. Lors de tests de référence utilisant le jeu de données LoCoMo10, les systèmes RAG traditionnels n'ont atteint que des taux d'achèvement des tâches de 35 à 44 % tout en consommant 24 à 51 millions de tokens d'entrée.

OpenViking adopte une approche différente. Créé par l'équipe OpenViking de ByteDance, il remplace le stockage vectoriel plat par un paradigme de système de fichiers. Tout le contexte réside sous des URI viking:// avec un chargement hiérarchique L0/L1/L2. Le résultat : un achèvement des tâches de 52 % avec 91 % de tokens en moins.

💡 Les utilisateurs d'Apidog qui développent des agents de test d'API peuvent intégrer OpenViking pour maintenir le contexte de conversation entre les exécutions de tests, mémoriser les préférences d'environnement de l'utilisateur et stocker la documentation API pour une récupération sémantique.

Dans ce guide, vous apprendrez comment OpenViking résout la fragmentation du contexte, verrez le modèle L0/L1/L2 en action et déploierez votre premier serveur en 15 minutes.

Le problème du contexte des agents

Les agents IA sont confrontés à des défis de contexte que les applications traditionnelles n'ont jamais rencontrés.

Considérez un agent aidant les développeurs à tester des API. Sur une semaine, il doit suivre :

  • Préférences de l'utilisateur (« environnement de staging », « curl plutôt que Python »)
  • Contexte du projet (points de terminaison, méthodes d'authentification, résultats des tests passés)
  • Modèles d'outils (quels points de terminaison échouent, erreurs de schéma courantes)
  • Historique des tâches (ce qui a été testé, les bugs apparus)

Le RAG traditionnel stocke cela sous forme de fragments plats dans une base de données vectorielle. Interrogez-le, et vous obtenez les K fragments les plus similaires sans structure, sans hiérarchie et sans visibilité sur ce qui a été manqué.

Cinq défis fondamentaux

OpenViking identifie cinq problèmes fondamentaux dans la gestion du contexte des agents :

Défi RAG traditionnel Solution OpenViking
Contexte fragmenté Mémoires, ressources, compétences stockées séparément Paradigma de système de fichiers unifié sous viking://
Demande croissante Les tâches longues génèrent un contexte massif Le chargement hiérarchique L0/L1/L2 réduit les tokens de 91 %
Mauvaise récupération La recherche vectorielle plate manque de vue globale Récupération récursive de répertoire avec analyse d'intention
Inobservable Chaînes de récupération boîte noire Trajectoires de recherche visualisées pour le débogage
Itération limitée Seul l'historique d'interaction de l'utilisateur Gestion automatique de session avec 6 catégories de mémoire

Cela représente un passage de « tout stocker, récupérer vaguement » à « tout structurer, récupérer précisément ».

Qu'est-ce qu'OpenViking ?

OpenViking est une base de données de contexte open-source pour les agents IA, créée par l'équipe OpenViking de ByteDance sous licence Apache 2.0.

Diagramme d'architecture OpenViking

Il unifie tout le contexte en un système de fichiers virtuel. Les mémoires, ressources et compétences sont mappées à des répertoires sous viking://, chacun avec un URI unique.

viking://
├── resources/              # Connaissances externes : docs, code, pages web
│   ├── my_project/
│   │   ├── docs/
│   │   │   ├── api/
│   │   │   └── tutorials/
│   │   └── src/
│   └── ...
├── user/                   # Spécifique à l'utilisateur : préférences, habitudes
│   └── memories/
│       ├── preferences/
│       │   ├── writing_style
│       │   └── coding_habits
│       └── ...
└── agent/                  # Capacités de l'agent : compétences, mémoires de tâches
    ├── skills/
    │   ├── search_code
    │   ├── analyze_data
    │   └── ...
    ├── memories/
    └── instructions/
Enter fullscreen mode Exit fullscreen mode

Les agents acquièrent des capacités de manipulation directe du contexte :

  • Naviguer dans les répertoires avec ls viking://resources/my_project/docs/
  • Rechercher sémantiquement avec find "méthodes d'authentification"
  • Lire le contenu complet avec read viking://resources/docs/auth.md
  • Obtenir des résumés rapides avec abstract viking://resources/docs/

Pensez-y comme la différence entre la recherche sur tout votre disque dur et le fait de savoir exactement quel répertoire contient le fichier.

Fonctionnalité clé 1 : Paradigme de gestion du système de fichiers

Le paradigme du système de fichiers résout la fragmentation du contexte en unifiant tous les types de contexte sous un modèle unique.

Trois types de contexte

Type Objectif Cycle de vie Initiative
Ressource Connaissances externes (docs, code, FAQ) Long terme, statique L'utilisateur
Mémoire Cognition de l'agent (préférences, expériences) Long terme, dynamique L'agent
Compétence Capacités appelables (outils, MCP) Long terme, statique L'agent

Chaque type réside dans son propre répertoire :

  • viking://resources/: Manuels produits, dépôts de code, documentation
  • viking://user/memories/: Préférences utilisateur, mémoires d'entités, événements
  • viking://agent/skills/: Définitions d'outils, configurations MCP
  • viking://agent/memories/: Modèles appris, études de cas

API de type Unix

OpenViking fournit des opérations de ligne de commande familières :

from openviking import OpenViking

client = OpenViking(path="./data")

# Recherche sémantique à travers tous les types de contexte
results = client.find("user authentication")

# Lister le contenu du répertoire
contents = client.ls("viking://resources/")

# Lire le contenu complet
doc = client.read("viking://resources/docs/auth.md")

# Obtenir un résumé rapide (couche L0)
abstract = client.abstract("viking://resources/docs/")

# Obtenir un aperçu détaillé (couche L1)
overview = client.overview("viking://resources/docs/")
Enter fullscreen mode Exit fullscreen mode

L'API fonctionne via le SDK Python ou un serveur HTTP, compatible avec tout framework d'agent.

Fonctionnalité clé 2 : Chargement de contexte hiérarchique L0/L1/L2

Empiler un contexte massif dans les prompts est coûteux et sujet aux erreurs. OpenViking traite automatiquement tout le contexte en trois couches hiérarchiques :

Couche Nom Fichier Limite de tokens Objectif
L0 Résumé .abstract.md ~100 tokens Recherche vectorielle, filtrage rapide
L1 Aperçu .overview.md ~2k tokens Reclassement, navigation de contenu
L2 Détail Fichiers originaux Illimité Contenu complet, chargement à la demande

Comment ça marche

Quand vous ajoutez une ressource (ex. un PDF), OpenViking :

  1. Analyse le document en texte (pas d'appels LLM au départ)
  2. Construit une structure arborescente de répertoires dans le stockage AGFS
  3. Met en file d'attente le traitement sémantique de manière asynchrone
  4. Génère des résumés L0 et des aperçus L1 de bas en haut

Exemple de structure après ajout :

viking://resources/my_project/
├── .abstract.md               # L0 : Résumé
├── .overview.md               # L1 : Aperçu détaillé
├── docs/
│   ├── .abstract.md
│   ├── .overview.md
│   ├── auth.md               # L2 : Contenu complet
│   ├── endpoints.md
│   └── rate-limits.md
└── src/
    └── ...
Enter fullscreen mode Exit fullscreen mode

Impact sur le budget de tokens

Cette hiérarchie permet des économies significatives :

# RAG traditionnel : Charger tout le contenu
full_docs = retrieve_all("authentication")  # 50k tokens

# OpenViking : Commencer avec L1, charger L2 uniquement si nécessaire
overview = client.overview("viking://resources/docs/auth/")  # 2k tokens

if needs_more_detail(overview):
    content = client.read("viking://resources/docs/auth/oauth.md")  # Charger un L2 spécifique
Enter fullscreen mode Exit fullscreen mode

Lors des tests de référence, cette approche a réduit les coûts de tokens d'entrée de 91 % par rapport au RAG traditionnel tout en améliorant les taux d'achèvement des tâches de 43 %.

Fonctionnalité clé 3 : Récupération récursive de répertoire

La recherche vectorielle simple échoue sur les requêtes complexes. OpenViking implémente une stratégie de récupération récursive de répertoire en cinq étapes :

1. Intent Analysis
   ↓
2. Initial Positioning (find high-score directories)
   ↓
3. Refined Exploration (search within directories)
   ↓
4. Recursive Descent (drill into subdirectories)
   ↓
5. Result Aggregation (return ranked contexts)
Enter fullscreen mode Exit fullscreen mode

Étape 1 : Analyse de l'intention

  • Exemple : « comment authentifier les utilisateurs ? »
  • Détection de l'intention, entités clés, attentes de contenu

Étape 2 : Positionnement initial

  • Recherche vectorielle pour localiser les répertoires à score élevé

Étape 3 : Exploration raffinée

  • Recherche secondaire dans le répertoire cible pour trouver les fichiers précis

Étape 4 : Descente récursive

  • Si des sous-répertoires existent, la recherche continue récursivement

Étape 5 : Agrégation des résultats

  • Regroupement et classement des résultats, trace de récupération conservée

Cette stratégie « répertoire d'abord, contenu ensuite » améliore la précision en tenant compte du contexte global.

Fonctionnalité clé 4 : Traces de récupération visualisées

Le RAG traditionnel est une boîte noire. OpenViking rend la récupération observable :

Trace de récupération pour la requête : "Actualisation du token OAuth"

├── viking://resources/docs/
│   ├── [SCORE: 0.45] .abstract.md : ignoré (faible pertinence)
│   └── [SCORE: 0.89] auth/ : sélectionné (haute pertinence)
│       ├── [SCORE: 0.92] oauth.md : RENVOYÉ
│       ├── [SCORE: 0.34] jwt.md : ignoré
│       └── [SCORE: 0.78] providers/
│           └── [SCORE: 0.85] google.md : RENVOYÉ
Enter fullscreen mode Exit fullscreen mode

Vous voyez ainsi :

  • Les répertoires visités
  • Pourquoi certains fichiers sont sélectionnés ou non
  • Le chemin exact de récupération

Pour le débogage, c'est essentiel.

Fonctionnalité clé 5 : Gestion automatique des sessions

OpenViking intègre une boucle d'auto-itération de la mémoire. À la fin de chaque session, des mémoires sont extraites et le contexte est mis à jour automatiquement.

Six catégories de mémoire

Catégorie Propriétaire Emplacement Description Stratégie de mise à jour
profil utilisateur user/memories/.overview.md Informations utilisateur Modifiable par ajout
préférences utilisateur user/memories/preferences/ Préférences par sujet Modifiable par ajout
entités utilisateur user/memories/entities/ Personnes, projets Modifiable par ajout
événements utilisateur user/memories/events/ Décisions, jalons Pas de mise à jour
cas agent agent/memories/cases/ Cas appris Pas de mise à jour
modèles agent agent/memories/patterns/ Modèles appris Pas de mise à jour

Extraction de mémoire : exemple 

# Démarrer une session
session = client.session()

# Ajouter des messages (tours de conversation)
await session.add_message("user", [{"type": "text", "text": "Je préfère le mode sombre dans l'interface utilisateur"}])
await session.add_message("assistant", [{"type": "text", "text": "Bien compris. J'utiliserai le mode sombre pour toutes les captures d'écran futures."}])

# Enregistrer l'utilisation de l'outil
await session.add_usage({
    "tool": "screenshot",
    "parameters": {"theme": "dark"},
    "result": "success"
})

# Valider la session : déclenche l'extraction de mémoire
await session.commit()
Enter fullscreen mode Exit fullscreen mode

Après validation :

  1. Compresse la session (archive les plus anciens tours)
  2. Extrait les mémoires via analyse LLM
  3. Met à jour les répertoires de mémoire
  4. Génère L0/L1 pour les nouvelles mémoires

Ainsi, les agents apprennent à chaque session.

Vue d'ensemble de l'architecture

L'architecture système d'OpenViking sépare les préoccupations en plusieurs couches :

Diagramme d'architecture système OpenViking

Stockage double couche

Couche Technologie Stocke
AGFS Système de fichiers custom Contenu L0/L1/L2, fichiers, relations
Index vectoriel Base de données vectorielle URI, embeddings, métadonnées

Avantages :

  • Toutes les lectures de contenu sont unifiées (AGFS)
  • L'index vectoriel ne stocke que des références légères
  • Zéro duplication de gros blocs de texte

Démarrage rapide : Déployez votre premier serveur OpenViking

Prérequis

  • Python : 3.10+
  • Go : 1.22+ (pour AGFS)
  • Compilateur C++ : GCC 9+ ou Clang 11+
  • OS : Linux, macOS ou Windows

Étape 1 : Installer OpenViking 

pip install openviking --upgrade --force-reinstall
Enter fullscreen mode Exit fullscreen mode

Optionnel : installer la CLI Rust

curl -fsSL https://raw.githubusercontent.com/volcengine/OpenViking/main/crates/ov_cli/install.sh | bash
Enter fullscreen mode Exit fullscreen mode

Étape 2 : Configurer les modèles

Créez ~/.openviking/ov.conf :

{
  "storage": {
    "workspace": "/home/your-name/openviking_workspace"
  },
  "log": {
    "level": "INFO",
    "output": "stdout"
  },
  "embedding": {
    "dense": {
      "api_base": "https://api.openai.com/v1",
      "api_key": "your-openai-api-key",
      "provider": "openai",
      "dimension": 3072,
      "model": "text-embedding-3-large"
    },
    "max_concurrent": 10
  },
  "vlm": {
    "api_base": "https://api.openai.com/v1",
    "api_key": "your-openai-api-key",
    "provider": "openai",
    "model": "gpt-4o",
    "max_concurrent": 100
  }
}
Enter fullscreen mode Exit fullscreen mode

Fournisseurs supportés

Fournisseur Modèles d'embedding Modèles VLM
volcengine doubao-embedding-vision doubao-seed-2.0-pro
openai text-embedding-3-large gpt-4o, gpt-4-vision
litellm via proxy LiteLLM Claude, Gemini, etc.

Le support LiteLLM permet d'utiliser Anthropic, Google, Ollama ou tout endpoint compatible OpenAI.

Étape 3 : Démarrer le serveur 

openviking-server
Enter fullscreen mode Exit fullscreen mode

Ou en arrière-plan :

nohup openviking-server > /data/log/openviking.log 2>&1 &
Enter fullscreen mode Exit fullscreen mode

Étape 4 : Ajouter votre première ressource 

# Interface CLI Rust
ov add-resource https://docs.example.com/api-guide.pdf

# SDK Python
from openviking import OpenViking

client = OpenViking(path="./data")
client.add_resource("https://docs.example.com/api-guide.pdf")
Enter fullscreen mode Exit fullscreen mode

Étape 5 : Rechercher et récupérer 

# Attendre le traitement sémantique, puis rechercher
ov find "authentication methods"

# Lister le contenu du répertoire
ov ls viking://resources/

# Afficher l'arborescence du répertoire
ov tree viking://resources/docs -L 2

# Rechercher du contenu spécifique
ov grep "OAuth" --uri viking://resources/docs/
Enter fullscreen mode Exit fullscreen mode

Étape 6 : Activer VikingBot (facultatif) 

pip install "openviking[bot]"

# Démarrer le serveur avec le bot activé
openviking-server --with-bot

# Chat interactif
ov chat
Enter fullscreen mode Exit fullscreen mode

Benchmarks de performance

OpenViking a été évalué face au RAG traditionnel (LanceDB) et à la mémoire native avec le jeu de données LoCoMo10 (1 540 cas de dialogue à longue portée).

Taux d'achèvement des tâches

Système Taux d'achèvement Tokens d'entrée
OpenClaw (mémoire native) 35.65% 24.6M
OpenClaw + LanceDB 44.55% 51.6M
OpenClaw + OpenViking 52.08% 4.3M

Principales conclusions

  • +43 % vs mémoire native ; -91 % de tokens
  • +17 % vs LanceDB ; -92 % de tokens
  • La hiérarchie d'OpenViking trouve plus de contexte pertinent avec moins de tokens

Ces résultats proviennent de l'intégration d'OpenViking comme plugin avec OpenClaw, un assistant de codage IA open-source.

Intégrer OpenViking avec Apidog

Les utilisateurs d'Apidog qui développent des agents IA pour les tests d'API peuvent exploiter OpenViking pour maintenir le contexte de conversation, stocker la documentation API et mémoriser les préférences de l'utilisateur d'une session à l'autre.

Tableau de bord Apidog affichant la documentation API et les cas de test

Étape 1 : Configurer le serveur OpenViking

Suivez le démarrage rapide ci-dessus pour déployer OpenViking avec vos modèles VLM et d'embedding préférés.

Étape 2 : Importer la documentation API Apidog 

# Ajouter la documentation de votre projet Apidog comme ressource
ov add-resource https://docs.apidog.com/overview?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation
ov add-resource https://docs.apidog.com/api-testing?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation
Enter fullscreen mode Exit fullscreen mode

Ceci importe la documentation Apidog dans viking://resources/ avec un traitement L0/L1/L2 automatique.

Étape 3 : Stocker les préférences de l'utilisateur 

from openviking import OpenViking

client = OpenViking(path="./apidog-agent-data")
session = client.session()

# Enregistrer la préférence d'environnement par défaut de l'utilisateur
await session.add_message("user", [{
    "type": "text",
    "text": "Toujours utiliser l'environnement de staging pour les tests API"
}])
await session.commit()  # Extrait automatiquement la mémoire de préférence
Enter fullscreen mode Exit fullscreen mode

Étape 4 : Interroger le contexte pendant les tests 

# Trouver les points de terminaison API pertinents avant d'exécuter les tests
results = client.find("points de terminaison d'authentification")
for ctx in results.resources:
    print(f"Found: {ctx.uri}")

# Récupérer la préférence d'environnement de l'utilisateur
prefs = client.find("préférence d'environnement de staging", target_uri="viking://user/memories/")
Enter fullscreen mode Exit fullscreen mode

Étape 5 : Connecter à votre framework d'agent

OpenViking expose un SDK Python et une API HTTP :

# SDK Python
from openviking import OpenViking
client = OpenViking(path="./data")

# Ou API HTTP
import httpx
response = httpx.post(
    "http://localhost:1933/api/v1/search/find",
    json={"query": "points de terminaison d'authentification"},
    headers={"X-API-Key": "votre-clé-api"}
)
Enter fullscreen mode Exit fullscreen mode

Techniques avancées et bonnes pratiques

Conseils de pro pour les déploiements en production

1. Pré-charger le contexte fréquemment accédé

# Déclencher le traitement sémantique immédiatement
ov add-resource https://docs.example.com --wait
Enter fullscreen mode Exit fullscreen mode

2. Mettre en œuvre l'expiration du contexte

# Archiver les sessions de plus de 7 jours
await session.archive(max_age_days=7)
Enter fullscreen mode Exit fullscreen mode

3. Surveiller la santé de l'index vectoriel

ov debug stats
Enter fullscreen mode Exit fullscreen mode

Erreurs courantes à éviter

  1. Charger le contenu L2 prématurément : commencez toujours par L0/L1
  2. Omettre les validations de session : l'extraction de mémoire a lieu à la validation
  3. Surcharger des répertoires uniques : subdivisez vos ressources
  4. Ignorer les traces de récupération : exploitez-les pour le débogage

Optimisation des performances

Scénario Recommandation
Volume de requêtes élevé Serveur HTTP avec pool de connexions
Documents volumineux Chunks basés sur sujets avant import
Besoins de faible latence Pré-générer L0/L1 pour contenu critique
Multi-locataire Espaces de travail séparés par locataire

Bonnes pratiques de sécurité

  • Stocker les clés API dans des variables d'environnement ou gestionnaire de secrets
  • Activer HTTPS pour tous les déploiements HTTP
  • Limiter le débit sur les endpoints publics
  • Séparer les clés API dev/prod

Cas d'utilisation réels

1. Assistants de codage IA

Une équipe de développement a intégré OpenViking à son assistant de codage interne, permettant :

  • Navigation structurée dans le code (viking://resources/my_project/src/)
  • Rétention des préférences de codage utilisateur
  • Récupération de documentation API pertinente

Résultat : -67 % de comportements « oublieux », -43 % de coût tokens.

2. Agents de support client

Déploiement d'OpenViking pour chatbot SaaS :

  • Documentation produit dans viking://resources/product/
  • Historique client dans viking://user/memories/past_issues/
  • Guides de support comme compétences

Résultat : résolution au premier contact : 52 % → 71 %.

3. Assistants de recherche

Un laboratoire de recherche organise articles et notes :

  • Articles par sujet (viking://resources/papers/nlp/)
  • Méthodologies stockées comme compétences
  • Extraction automatique de découvertes clés

Résultat : recherche d'articles 3x plus rapide.

Alternatives et comparaisons

OpenViking vs. Bases de données vectorielles traditionnelles

Aspect RAG traditionnel (Pinecone, LanceDB) OpenViking
Modèle de stockage Fragments vectoriels plats Système de fichiers hiérarchique
Récupération Similarité Top-K Récursif + analyse d'intention
Observabilité Boîte noire Traces visualisées
Efficacité tokens Charger tout ou tronquer Chargement progressif L0/L1/L2
Itération mémoire Manuelle ou aucune Sessions auto
Types de contexte Documents uniquement Ressources, mémoires, compétences unifiées
Débogage Conjectures Journaux de parcours de répertoire

OpenViking vs. Mémoire LangChain

Aspect Mémoire LangChain OpenViking
Persistance Tampon de conversation Système de fichiers (L0/L1/L2)
Scalabilité Limitée à la fenêtre Hiérarchique, pas de limite stricte
Récupération Recherche linéaire Récursive + sémantique
Types de mémoire Tampon unique 6 catégories (profil, préférences, événements…)

Quand choisir l'alternative ?

  • Bases vectorielles : latence < 100 ms, simple recherche, pipeline RAG déjà en place
  • OpenViking : conversations longues, contexte multi-type, optimisation tokens, besoin de débogage

Comparaison avec le RAG traditionnel

Aspect RAG traditionnel OpenViking
Modèle de stockage Fragments vectoriels Système de fichiers hiérarchique
Récupération Similarité Top-K Récursif + analyse d'intention
Observabilité Boîte noire Traces visualisées
Efficacité tokens Tout charger/tronquer Chargement progressif L0/L1/L2
Itération mémoire Manuelle/aucune Sessions auto
Types de contexte Docs uniquement Ressources, mémoires, compétences unifiées
Débogage Conjectures Parcours de répertoire

Déploiement en production

Exécutez OpenViking comme service HTTP autonome.

Infrastructure recommandée

  • Cloud : Volcengine ECS ou équivalent
  • OS : veLinux ou Ubuntu 22.04+
  • Stockage : SSD pour AGFS
  • Réseau : faible latence vers les API modèles

Considérations de sécurité

  • Stocker les clés API dans des variables d'environnement ou gestionnaire de secrets
  • Activer l'authentification sur les endpoints HTTP
  • Utiliser HTTPS
  • Limiter le débit

Surveillance

OpenViking supporte la journalisation et les métriques :

{
  "log": {
    "level": "INFO",
    "output": "file",
    "path": "/var/log/openviking/server.log"
  }
}
Enter fullscreen mode Exit fullscreen mode

Surveillez :

  • Profondeur de la file de traitement sémantique
  • Latence des recherches vectorielles
  • AGFS lectures/écritures
  • Taux de succès extraction mémoire

Limitations et considérations

Limitations actuelles

  • Orienté Python : SDK principal en Python, autres langages via HTTP
  • Dépendances modèles : nécessite modèles embedding/VLM externes
  • Courbe d'apprentissage : paradigme système de fichiers différent
  • Phase précoce : APIs susceptibles d'évoluer

Quand utiliser OpenViking

Bonne adéquation :

  • Conversations d'agents longues
  • Contexte multi-type
  • Besoin de récupération observable
  • Optimisation tokens importante

Considérez les alternatives :

  • Q/R ponctuelles
  • Pipeline RAG OK actuellement
  • Latence < 100 ms indispensable

La feuille de route

OpenViking est en développement actif (0.1.x début 2025). Feuille de route :

  • Multi-locataire : espaces de travail par équipe
  • Analyses avancées : métriques récupération, tableaux bord mémoire
  • Plugins : intégrations frameworks agents populaires
  • Déploiement edge : mode léger local
  • Support MCP natif

Le projet est open source Apache 2.0, documentation disponible.

Conclusion

OpenViking représente un changement dans la gestion du contexte agent IA. En organisant l'information comme un système de fichiers au lieu de fragments plats, il résout la fragmentation, le gaspillage de tokens et la récupération opaque des systèmes RAG traditionnels.

Points clés à retenir

  • Le paradigme système de fichiers unifie le contexte : mémoires, ressources, compétences sous viking://
  • Le chargement L0/L1/L2 réduit les tokens de 91 %
  • La récupération récursive améliore la précision
  • Les traces visualisées facilitent le débogage
  • La gestion automatique des sessions permet l'apprentissage continu

Top comments (0)