API Mémoire Kronvex

Connectez votre agent IA en une seule commande.

Détecte automatiquement Claude Desktop, Claude Code, Cursor, Windsurf, Cline et Gemini CLI. Demande votre clé API et configure tout en quelques secondes.

Détecte les agents installés, écrit la config MCP automatiquement. Ou suivez un guide manuel ci-dessous. Récupérez votre clé gratuite.

npx @kronvex/setup --key kv-your-key --agent your-agent-id

Passez --key et --agent pour ignorer les questions interactives — utile pour le provisioning automatisé.

Règles agent — apprenez à Claude à utiliser la mémoire automatiquement

Ajoutez ces instructions à votre CLAUDE.md (or any project's .claude/skills/memory.md) pour que Claude charge et sauvegarde le contexte automatiquement à chaque tâche — sans qu'on lui demande :

## Memory Protocol (Kronvex)

BEFORE every task:
- Call `kronvex_recall` with the current task description as the query
- Inject any returned memories into your working context

AFTER every task:
- Call `kronvex_remember` to store:
  - Key decisions made
  - Patterns or preferences discovered
  - Architecture choices and their rationale
  - Anything that would help in future sessions

Memory types to use:
- `procedural` — how to do things (preferred approaches, commands, style rules)
- `semantic`   — facts about the project (stack, team, constraints)
- `episodic`   — what happened (bugs fixed, features shipped, blockers hit)

Ask Claude: "Use Kronvex to remember that I prefer TypeScript strict mode."
→ Claude calls kronvex_remember and confirms: "Memory stored."

Ask Claude: "What are my coding preferences?"
→ Claude calls kronvex_recall and returns the memory above.

Règles Cursor — mémoire automatique à chaque tâche

Add this rule to .cursor/rules/kronvex.mdc pour que l'agent Cursor rappelle et stocke le contexte automatiquement à chaque tâche :

---
description: Persistent memory via Kronvex MCP
globs: ["**/*"]
alwaysApply: true
---

## Kronvex Memory Protocol

BEFORE starting any task:
1. Call `kronvex_recall` with the task description as query
2. Read returned memories and incorporate them into your plan

AFTER completing any task:
1. Call `kronvex_remember` to store:
   - Architecture decisions made
   - Patterns and conventions established
   - Bugs fixed and their root causes
   - Preferences expressed by the user

Use memory_type: "procedural" for how-to knowledge, "semantic" for project facts.

In Cursor agent mode: "Remember that this project uses pnpm workspaces."
→ Cursor calls kronvex_remember → "Memory stored successfully."

Next session: "What's the package manager for this project?"
→ Cursor calls kronvex_recall → returns the memory above.

Règles Cline — mémoire automatique à chaque tâche

Create .clinerules/kronvex.md à la racine de votre projet pour apprendre à Cline à charger et sauvegarder la mémoire automatiquement :

## Memory Protocol (Kronvex)

BEFORE every task:
1. Call `kronvex_recall` with the current task description as query
2. Incorporate returned memories into your plan

AFTER every task:
1. Call `kronvex_remember` to store:
   - Architecture decisions made
   - Patterns and conventions discovered
   - Bugs fixed and their root causes
   - User preferences and constraints

Use memory_type: "procedural" for how-to knowledge, "semantic" for project facts,
"episodic" for events (bugs, deploys, decisions).

Ask Cline: "Use Kronvex to remember that this project uses ESLint with airbnb config."
→ Cline calls kronvex_remember → "Memory stored successfully."

Next session: "What linter config does this project use?"
→ Cline calls kronvex_recall → returns the memory above.

Règles Windsurf — mémoire automatique à chaque tâche

Create .windsurf/rules/kronvex.md à la racine de votre projet pour apprendre à Cascade à rappeler et stocker la mémoire automatiquement :

## Memory Protocol (Kronvex)

BEFORE every task:
1. Call `kronvex_recall` with the current task description as query
2. Incorporate returned memories into your plan

AFTER every task:
1. Call `kronvex_remember` to store:
   - Architecture and design decisions
   - Patterns and conventions established
   - Preferences expressed by the user
   - Bugs fixed and their root causes

Prefer memory_type "procedural" for workflows, "semantic" for project facts.

Ask Cascade: "Use Kronvex to remember that I prefer dark theme in all projects."
→ Cascade calls kronvex_remember → "Memory stored successfully."

Next session: "What are my UI preferences?"
→ Cascade calls kronvex_recall → returns the memory above.

GEMINI.md — mémoire automatique à chaque tâche

Add this block to GEMINI.md à la racine de votre projet (ou ~/.gemini/GEMINI.md au global) pour apprendre à Gemini CLI à utiliser Kronvex automatiquement :

## Memory Protocol (Kronvex)

BEFORE every task:
1. Call `kronvex_recall` with the current task description as query
2. Incorporate returned memories into your plan

AFTER every task:
1. Call `kronvex_remember` to store:
   - Key decisions and their rationale
   - Patterns discovered in the codebase
   - User preferences and constraints
   - Bugs resolved and root causes

Use memory_type: "semantic" for facts, "procedural" for workflows.

gemini "Use Kronvex to remember that I prefer dark theme in all projects."
→ Gemini calls kronvex_remember → "Memory stored successfully."

Next session: "What are my UI preferences?"
→ Gemini calls kronvex_recall → returns the memory above.

Instructions Copilot — mémoire automatique à chaque tâche

Create .github/copilot-instructions.md à la racine de votre projet pour apprendre à Copilot à utiliser la mémoire automatiquement :

## Memory Protocol (Kronvex)

BEFORE every task:
1. Call `kronvex_recall` with the current task description as query
2. Incorporate returned memories into your plan

AFTER every task:
1. Call `kronvex_remember` to store:
   - Architecture and design decisions
   - Coding standards and conventions
   - Personal preferences expressed
   - Bugs fixed and root causes found

Use memory_type: "procedural" for coding conventions, "semantic" for project facts.

In Copilot Chat: "Use Kronvex to remember that our API uses REST with JSON:API spec."
→ Copilot calls kronvex_remember → "Memory stored successfully."

Next session: "What API spec does this project use?"
→ Copilot calls kronvex_recall → returns the memory above.

Tout client MCP

Call tool: kronvex_recall  with  { "agent_id": "test-agent", "query": "test" }
→ Doit retourner une liste vide (aucune mémoire pour l'instant) — confirme que la connexion fonctionne.

Kilo Code

In Kilo Code chat: "remember that this project uses TypeScript strict mode"
→ Kilo Code calls kronvex_remember → "Memory stored."

Next session: "what are the project conventions?"
→ Kilo Code calls kronvex_recall → returns the memory above.

OpenCode

Tell OpenCode: "remember that we use pnpm, not npm"
→ calls kronvex_remember → "Memory stored."

Later: "what package manager does this project use?"
→ calls kronvex_recall → returns the memory above.

ChatGPT

In ChatGPT: "remember that I'm working on a SaaS product called Kronvex"
→ ChatGPT calls kronvex_remember → "Memory stored."

Next session: "what product am I working on?"
→ ChatGPT calls kronvex_recall → returns the memory above.

Compatible avec toute votre stack IA.

Si ça peut faire un HTTP POST, ça fonctionne déjà avec Kronvex. SDKs natifs Python et Node.js, adaptateurs pour LangChain, CrewAI et plus, plus des nodes no-code pour n8n et Flowise.

Vous ne voyez pas votre intégration ?

Kronvex est REST en premier — si votre outil peut faire une requête HTTP, ça fonctionne dès aujourd'hui. SDK natif ou tutoriel manquant ? Faites-le nous savoir.

AutoGen

result = agent.remember("AutoGen integration test")
print(result)  # → {"id": "...", "content": "AutoGen integration test"}

Flowise

Dify

Python SDK

Lancez le snippet ci-dessus.
→ Doit afficher : "User prefers formal tone"

Node.js / TypeScript SDK

Lancez le snippet ci-dessus avec ts-node ou tsx.
→ Doit afficher : "User prefers formal tone"

LangChain / LangGraph

memory.save_context({"input": "test"}, {"output": "hello"})
memories = memory.load_memory_variables({})
print(memories)
→ Doit afficher le contexte stocké depuis Kronvex.

CrewAI

result = tool._run("remember: project uses Python 3.11")
print(result)
→ Should return a confirmation string from Kronvex.

n8n

Execute a "Remember" node with content: "test memory from n8n"
→ La sortie du node doit afficher { "id": "...", "content": "test memory from n8n" }

OpenAI Agents SDK

print(remember("Test memory from OpenAI Agents SDK"))
→ Doit afficher : "Stored"
print(recall("test"))
→ Doit afficher : "Test memory from OpenAI Agents SDK"

Grok SDK (xAI)

print(chat("My stack is FastAPI + PostgreSQL"))
# Second appel — Grok se souvient de votre stack
print(chat("What database should I use for a new microservice?"))
→ Grok répond en se basant sur le contexte stocké.

Mistral AI SDK

1. Installez les dépendances:

pip install kronvex mistralai

2. Utilisez Kronvex avec le SDK Python Mistral AI :

from mistralai import Mistral
from kronvex import Kronvex

mistral = Mistral(api_key="your-mistral-key")
kv      = Kronvex(api_key="kv-your-key")

AGENT = "mistral-agent"

def chat(user_msg: str) -> str:
    # Retrieve past context relevant to this message
    ctx = kv.inject_context(AGENT, user_msg)
    resp = mistral.chat.complete(
        model="mistral-large-latest",
        messages=[
            {"role": "system",  "content": ctx},
            {"role": "user",    "content": user_msg},
        ]
    )
    answer = resp.choices[0].message.content
    # Persist the exchange for future recall
    kv.remember(AGENT, f"User: {user_msg}\nMistral: {answer}")
    return answer

print(chat("My stack is FastAPI + PostgreSQL"))
# Second appel — Mistral se souvient de votre stack
print(chat("What ORM should I use with my database?"))
→ Mistral répond en se basant sur le contexte stocké.

Claude Agent SDK

print(chat("I'm building a SaaS with Stripe and FastAPI"))
# Second message — Claude se souvient de votre stack
print(chat("What auth approach fits my stack?"))
→ Claude répond avec le contexte complet depuis la mémoire.

Google ADK

result = agent.run("remember: our CI runs on GitHub Actions")
# Later:
result = agent.run("how does our CI work?")
→ L'agent rappelle la mémoire et répond correctement.

Vercel AI SDK

// First call
generateText({ prompt: "I prefer TypeScript with strict mode" })
→ Agent calls remember → "Stored"

// Next request — agent has full context
generateText({ prompt: "set up my tsconfig" })
→ Agent generates config with strictMode: true

REST API (curl)

Lancez la commande de stockage ci-dessus.
→ Doit retourner : { "id": "...", "content": "User prefers formal tone", "confidence": 1.0 }

Ce que vous pouvez construire avec Kronvex

Du support client à la recherche juridique — tout agent IA B2B qui interagit avec des humains s'améliore mesurablement avec une mémoire persistante.

Agents de support qui connaissent vos utilisateurs

Your AI support agent knows a user's full history — past tickets, preferences, account tier, prior resolutions. No more "can you repeat the issue?" — the agent already knows.

client.agents("support-bot").remember(
  "User John prefers email updates, on Pro plan since Jan, had billing issue in March"
)
ctx = client.agents("support-bot").inject_context("renewal question")

Agents de vente avec une mémoire deal parfaite

Chaque appel, chaque objection, chaque signal d'achat — votre agent IA commercial se souvient de tout et reprend la conversation suivante exactement où vous l'avez laissée.

# Après chaque appel commercial, persiste le contexte deal
client.agents("sales-bot").remember(
  "Acme Corp: budget €50k, decision by Q3, main blocker is IT security review",
  memory_type="episodic"
)

Assistants de code avec mémoire de projet

Votre outil dev IA retient les décisions d'architecture, les conventions de nommage, les notes de dette technique et les préférences d'équipe — il produit du code qui colle à votre vraie codebase.

Assistants juridiques avec mémoire de dossier

Votre IA juridique conserve tout le contexte du dossier — précédents cités, instructions client, historique des documents — entre toutes les sessions. Plus besoin de relire le dossier. Demandez simplement.

Assistants personnels avec mémoire long terme

Votre assistant IA construit un profil utilisateur persistant — préférences, habitudes, historique, objectifs — et porte ce contexte à travers chaque conversation, indéfiniment.

client.agents("personal-assistant").remember(
  "User prefers concise replies, morning briefings at 8am, based in Paris"
)
context = client.agents("personal-assistant").inject_context(user_message)