API Mémoire Kronvex

🦜

LangChain

Memory store adapter

🤖

CrewAI

Agent memory plugin

⚙️

n8n

HTTP node workflow

COPY

pip install kronvex langchain langchain-openai

COPY

from kronvex import Kronvex
from langchain.memory import BaseMemory
from langchain.schema import BaseMessage
from typing import Dict, Any, List

class KronvexMemory(BaseMemory):
    """Persistent cross-session memory powered by Kronvex."""

    client: Any = None
    agent: Any = None
    memory_key: str = "history"

    def __init__(self, api_key: str, agent_id: str, **kwargs):
        super().__init__(**kwargs)
        self.client = Kronvex(api_key)
        self.agent = self.client.agent(agent_id)

    @property
    def memory_variables(self) -> List[str]:
        return [self.memory_key]

    def load_memory_variables(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
        query = inputs.get("input", "")
        ctx = self.agent.inject_context(query=query, top_k=5)
        return {self.memory_key: ctx.context}

    def save_context(self, inputs: Dict[str, Any], outputs: Dict[str, Any]) -> None:
        user_msg = inputs.get("input", "")
        ai_msg = outputs.get("output", "")
        if user_msg:
            self.agent.remember(content=user_msg, memory_type="episodic")
        if ai_msg:
            self.agent.remember(content=ai_msg, memory_type="episodic")

    def clear(self) -> None:
        pass  # Use Kronvex dashboard to manage memories

COPY

from langchain_openai import ChatOpenAI
from langchain.chains import ConversationChain

memory = KronvexMemory(
    api_key="kv-your-api-key",
    agent_id="your-agent-id"
)

chain = ConversationChain(
    llm=ChatOpenAI(model="gpt-4o"),
    memory=memory,
    verbose=True
)

# Context from Kronvex is automatically injected
response = chain.predict(input="What are my preferences?")

💡 Tip: Set session_id in inject_context() to scope memories per conversation thread.

COPY

pip install kronvex crewai

COPY

from crewai import Agent, Task, Crew
from crewai.tools import tool
from kronvex import Kronvex

kv = Kronvex("kv-your-api-key")
agent_mem = kv.agent("your-agent-id")

@tool("Recall from memory")
def recall_memory(query: str) -> str:
    """Search past memories relevant to the query."""
    result = agent_mem.recall(query=query, top_k=5)
    return "
".join([m.content for m in result.memories])

@tool("Store in memory")
def store_memory(content: str) -> str:
    """Store a new piece of information in long-term memory."""
    agent_mem.remember(content=content, memory_type="semantic")
    return "Memory stored successfully."

# Attach tools to your agent
sales_agent = Agent(
    role="Sales Assistant",
    goal="Help customers based on their history",
    tools=[recall_memory, store_memory],
    verbose=True
)

Settings → Community Nodes → Install → n8n-nodes-kronvex

FIELD	VALUE
Method	POST
URL	https://api.kronvex.io/api/v1/agents/{{AGENT_ID}}/remember
Header	X-API-Key: kv-your-api-key
Body (JSON)	{"content": "{{$json.content}}", "memory_type": "episodic"}

COPY

POST https://api.kronvex.io/api/v1/agents/{{AGENT_ID}}/recall
X-API-Key: kv-your-api-key

{
  "query": "{{ $json.userMessage }}",
  "top_k": 5,
  "session_id": "{{ $json.sessionId }}"
}

💡 Schéma n8n : Déclencheur → HTTP (recall) → Nœud Agent IA → HTTP (stocker la réponse) → terminé. Les mémoires persistent automatiquement entre les exécutions du workflow.

Agents support qui connaissent vos utilisateurs

Votre agent IA de support connaît l'historique complet d'un utilisateur — tickets passés, préférences, niveau de compte, résolutions précédentes. Plus jamais "pouvez-vous répéter le problème ?" — l'agent sait déjà.

client.agents("support-bot").remember(
  "Utilisateur Jean préfère les mises à jour par email, plan Pro depuis janvier, problème de facturation en mars"
)
ctx = client.agents("support-bot").inject_context("question de renouvellement")

Agents commerciaux avec mémoire parfaite des deals

Chaque appel, chaque objection, chaque signal d'achat — votre agent IA commercial s'en souvient et reprend la prochaine conversation exactement là où vous vous étiez arrêté.

# Après chaque appel commercial, persister le contexte du deal
client.agents("sales-bot").remember(
  "Acme Corp : budget 50k€, décision avant Q3, frein principal : audit sécurité IT",
  memory_type="episodic"
)

Assistants de code avec mémoire de projet

Votre outil IA de développement se souvient des décisions d'architecture, des conventions de nommage, de la dette technique et des préférences de l'équipe — produisant du code qui s'adapte à votre vrai codebase.

Utilisé aussi pour

Détecte les agents installés et écrit la configuration MCP automatiquement. Ou suivez un guide manuel ci-dessous. Obtenez votre clé gratuite.

Agents & outils supportés

Claude

Desktop & Code

Cursor

mcp.json

Windsurf

mcp_config.json

Cline

Extension VS Code

Gemini CLI

settings.json

GitHub Copilot

VS Code / paramètres

Kilo Code

Extension VS Code

OpenCode

CLI Terminal

ChatGPT

Desktop (MCP)

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

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

npx @kronvex/setup

{
  "mcpServers": {
    "kronvex": {
      "command": "npx",
      "args": ["@kronvex/mcp"],
      "env": {
        "KRONVEX_API_KEY": "kv-your-key",
        "KRONVEX_AGENT_ID": "your-agent-uuid"
      }
    }
  }
}

Règles Agent — apprendre à Claude à utiliser la mémoire automatiquement

Ajoutez ces instructions dans votre CLAUDE.md pour que Claude charge et sauvegarde automatiquement le contexte à chaque tâche :

## 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)

Demandez à Claude : "Use Kronvex to remember that I prefer TypeScript strict mode."
→ Claude appelle kronvex_remember et confirme : "Memory stored."

Demandez à Claude : "What are my coding preferences?"
→ Claude appelle kronvex_recall et retourne la mémoire ci-dessus.

Étape 1 — Créez ou modifiez .cursor/mcp.json

{
  "mcpServers": {
    "kronvex": {
      "command": "npx",
      "args": ["@kronvex/mcp"],
      "env": {
        "KRONVEX_API_KEY": "kv-your-key",
        "KRONVEX_AGENT_ID": "your-agent-uuid"
      }
    }
  }
}

Étape 2 — Redémarrez Cursor (Cmd/Ctrl+Shift+P → "Developer: Reload Window").

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

Ajoutez cette règle dans .cursor/rules/kronvex.mdc :

---
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.

Étape 1 — Ouvrez les paramètres MCP de Cline

Dans VS Code : barre latérale Cline → bouton ⚙️ → "MCP Servers" → "Edit Config".

Étape 2 — Ajoutez la configuration Kronvex

{
  "mcpServers": {
    "kronvex": {
      "command": "npx",
      "args": ["@kronvex/mcp"],
      "env": {
        "KRONVEX_API_KEY": "kv-your-key",
        "KRONVEX_AGENT_ID": "your-agent-uuid"
      }
    }
  }
}

Étape 3 — Sauvegardez et relancez Cline. Le serveur Kronvex apparaîtra dans la liste des serveurs MCP connectés.

{
  "mcpServers": {
    "kronvex": {
      "command": "npx",
      "args": ["@kronvex/mcp"],
      "env": {
        "KRONVEX_API_KEY": "kv-your-key",
        "KRONVEX_AGENT_ID": "your-agent-uuid"
      }
    }
  }
}

Redémarrez Windsurf après avoir sauvegardé la configuration. Le serveur Kronvex sera détecté automatiquement.

{
  "mcpServers": {
    "kronvex": {
      "command": "npx",
      "args": ["@kronvex/mcp"],
      "env": {
        "KRONVEX_API_KEY": "kv-your-key",
        "KRONVEX_AGENT_ID": "your-agent-uuid"
      }
    }
  }
}

Relancez Gemini CLI après modification. Testez avec : gemini mcp list

{
  "mcp": {
    "servers": {
      "kronvex": {
        "command": "npx",
        "args": ["@kronvex/mcp"],
        "env": {
          "KRONVEX_API_KEY": "kv-your-key",
          "KRONVEX_AGENT_ID": "your-agent-uuid"
        }
      }
    }
  }
}

Rechargez la fenêtre VS Code (Cmd/Ctrl+Shift+P → "Developer: Reload Window"). Copilot utilisera Kronvex pour stocker et rappeler le contexte dans le mode Agent.

{
  "mcpServers": {
    "kronvex": {
      "command": "npx",
      "args": ["@kronvex/mcp"],
      "env": {
        "KRONVEX_API_KEY": "kv-your-key",
        "KRONVEX_AGENT_ID": "your-agent-uuid"
      }
    }
  }
}

{
  "mcp": {
    "kronvex": {
      "command": "npx",
      "args": ["@kronvex/mcp"],
      "env": {
        "KRONVEX_API_KEY": "kv-your-key",
        "KRONVEX_AGENT_ID": "your-agent-uuid"
      }
    }
  }
}

Fichier de configuration ChatGPT Desktop :

• Mac : ~/Library/Application Support/ChatGPT/mcp.json
• Windows : %APPDATA%\ChatGPT\mcp.json

{
  "mcpServers": {
    "kronvex": {
      "command": "npx",
      "args": ["@kronvex/mcp"],
      "env": {
        "KRONVEX_API_KEY": "kv-your-key",
        "KRONVEX_AGENT_ID": "your-agent-uuid"
      }
    }
  }
}

Redémarrez ChatGPT Desktop après avoir sauvegardé. Le serveur Kronvex sera disponible dans le mode de conversation.

2 min setup MCP · Universel

Appelez l'outil : kronvex_recall  avec  { "agent_id": "test-agent", "query": "test" }
→ Doit retourner une liste vide (pas encore de mémoires) — confirme que la connexion fonctionne.

Installation

pip install kronvex
# Extras disponibles :
pip install kronvex[langchain]  # adaptateur LangChain
pip install kronvex[crewai]     # plugin CrewAI
pip install kronvex[async]      # client asyncio (httpx)

Utilisation de base

from kronvex import Kronvex

client = Kronvex("kv-your-key")
agent = client.agents("my-agent")

# Stocker une mémoire
agent.remember("L'utilisateur préfère les réponses concises en français")

# Rappel sémantique
results = agent.recall(query="préférences utilisateur", top_k=5)

# Injecter le contexte dans un prompt système
context = agent.inject_context("Quelles sont les préférences de l'utilisateur ?")
print(context.context_block)  # à ajouter dans votre system prompt

Mode asynchrone (asyncio)

from kronvex import AsyncKronvex

async def main():
    client = AsyncKronvex("kv-your-key")
    agent = await client.agents("my-agent")
    await agent.remember("User completed onboarding step 3")
    results = await agent.recall(query="onboarding", top_k=3)
    print(results)

Installation

npm install kronvex
# ou
pnpm add kronvex

Utilisation TypeScript

import { Kronvex } from "kronvex";

const client = new Kronvex("kv-your-key");
const agent = await client.agents("my-agent");

// Stocker une mémoire
await agent.remember("User prefers dark mode and TypeScript strict");

// Rappel sémantique
const results = await agent.recall({ query: "user preferences", topK: 5 });

// Injecter dans un prompt
const { contextBlock } = await agent.injectContext("What are the user's coding preferences?");
// prepend contextBlock to your system message

💡 Tip : Le SDK supporte import (ESM) et require (CJS) sans configuration supplémentaire.

Installation

pip install kronvex pyautogen

Utilisation

from kronvex import Kronvex
import autogen

kv = Kronvex("kv-your-key")
agent = kv.agents("autogen-agent")

# Avant la conversation — injecter le contexte passé
context = agent.inject_context(query="préférences et historique utilisateur")

# Lancer AutoGen avec le contexte dans le system message
assistant = autogen.AssistantAgent(
    name="assistant",
    system_message=f"You are a helpful assistant.\n\n{context['prompt']}"
)

# Après la conversation — stocker ce qui s'est passé
agent.remember("L'utilisateur a demandé X, résolu avec Y")

results = agent.recall(query="test", top_k=1)
print(results)  # [] si aucune mémoire encore — connexion OK

Installation

pip install kronvex openai-agents

Pattern de base — mémoire avant/après chaque run

from kronvex import Kronvex
from agents import Agent, Runner

kv = Kronvex("kv-your-key")
mem = kv.agents("openai-agent")

# Avant chaque run — charger le contexte mémorisé
ctx = mem.inject_context(query="user context and preferences")
system_prompt = f"You are a helpful assistant.\n\n{ctx['prompt']}"

agent = Agent(name="assistant", instructions=system_prompt)
result = Runner.run_sync(agent, "Quelle est ma préférence pour les frameworks ?")

# Après le run — stocker les décisions importantes
mem.remember(f"User asked about frameworks. Response: {result.final_output[:200]}")

💡 Pattern multi-session : Utilisez memory_type="episodic" pour les faits de session et "semantic" pour les préférences stables.

Stocker une mémoire

curl -X POST https://api.kronvex.io/api/v1/agents/{agent_id}/remember \
  -H "X-API-Key: kv-your-key" \
  -H "Content-Type: application/json" \
  -d '{"content": "User prefers TypeScript strict mode", "memory_type": "semantic"}'

Rappel sémantique

curl -X POST https://api.kronvex.io/api/v1/agents/{agent_id}/recall \
  -H "X-API-Key: kv-your-key" \
  -H "Content-Type: application/json" \
  -d '{"query": "coding preferences", "top_k": 5}'

Injecter le contexte (bloc system prompt)

curl -X POST https://api.kronvex.io/api/v1/agents/{agent_id}/inject-context \
  -H "X-API-Key: kv-your-key" \
  -H "Content-Type: application/json" \
  -d '{"query": "user preferences and history", "top_k": 5}'

# Response:
# {
#   "context_block": "## Mémoires pertinentes\n- User prefers TypeScript strict mode...",
#   "memories_used": 3,
#   "prompt": "## Mémoires pertinentes\n..."
# }

💡 Compatible partout : Botpress, Voiceflow, Rasa, Flowise, Dify, n8n HTTP node — tout outil qui envoie du HTTP fonctionne avec Kronvex aujourd'hui.