Cognee connector for AI agents

CALL ANY TOOL

Run agent memory end to end: recall from the knowledge graph, provision and inspect datasets, enrich them, and forget data on demand.

cognee_recall

Recall memory

Run a semantic search over the knowledge graph and return an answer or matching context, with searchType controlling the retrieval strategy.

Parameters

Name

Type

Required

Description

query

string

Required

The natural-language question or search query to run against stored memory.

datasets

array

Optional

JSON array of dataset names to search. Names resolve only to datasets owned by the caller. Omit to search all accessible datasets.

nodeName

array

Optional

JSON array of node-set tags to restrict results to (the node_set values used when the data was remembered).

scope

array

Optional

JSON array selecting which memory sources to include, e.g. 'graph', 'session', 'triplets'. Omit to use the default graph search.

searchType

string

Optional

Retrieval strategy. GRAPH_COMPLETION (default) returns graph context plus an LLM answer. RAG_COMPLETION uses classic retrieval-augmented generation. CHUNKS and SUMMARIES return raw matching content. FEELING_LUCKY auto-selects a strategy.

sessionId

string

Optional

Session whose cached memory entries should also be searched. Pair with scope including 'session' to recall data saved with a session_id.

systemPrompt

string

Optional

Optional instructions that guide how the answer is generated for completion-type search strategies.

topK

integer

Optional

Maximum number of results to consider during retrieval. Defaults to 15.

cognee_list_datasets

List datasets

cognee_list_dataset_data

List dataset items

cognee_create_dataset

Create dataset

cognee_improve

Enrich memory

cognee_check_status

Check pipeline status

cognee_forget

Forget data

Build your Agent

Same auth pattern across LangChain, OpenAI, Anthropic, and Google ADK.

import { ScalekitClient } from "@scalekit-sdk/node";
import { createReactAgent } from "@langchain/langgraph/prebuilt";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

// Cognee tools scoped to this user
const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["cognee"], toolNames: [
    "cognee_recall",
    "cognee_list_datasets",
    "cognee_improve"] },
  pageSize: 100,
});

const agent = createReactAgent({ llm, tools });
await agent.invoke({ messages: [{ role: "user", content: "What do we know about Acme Corp?" }] });

import OpenAI from "openai";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);
const openai = new OpenAI();

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["cognee"] }, pageSize: 100,
});

const res = await openai.chat.completions.create({
  model: "gpt-5",
  messages: [{ role: "user", content: "Recall every decision about the pricing migration." }],
  tools,
});

// Execute the tool call with the user's vaulted Cognee credential
await sk.tools.executeTool(res.choices[0].message.tool_calls[0], "user_123");

import Anthropic from "@anthropic-ai/sdk";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);
const anthropic = new Anthropic();

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["cognee"] }, pageSize: 100,
});

const msg = await anthropic.messages.create({
  model: "claude-sonnet-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "List all datasets and what each one contains." }],
  tools,
});

// Tool call runs with the user's vaulted Cognee credential
await sk.tools.executeTool(msg.content, "user_123");

import { Agent } from "@google/adk/agents";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["cognee"] }, pageSize: 100,
});

const agent = new Agent({
  name: "cognee_memory_agent",
  model: "gemini-2.5-pro",
  instruction: "Manage Cognee memory for the signed-in user.",
  tools,
});

await agent.run("Has the enrichment run on support_tickets finished?");

Try these prompts

Copy any prompt into your agent. Each maps directly to a Cognee tool. Click to copy, paste into your agent, done.

Recall context

Copy the prompt

Copied

What do we know about Acme Corp's onboarding issues?

Copy the prompt

Copied

Recall every decision we logged about the pricing migration.

Copy the prompt

Copied

Search memory for past conversations that mention churn risk.

Manage datasets

Copy the prompt

Copied

List all datasets and their UUIDs.

Copy the prompt

Copied

Create a dataset called support_tickets for the new project.

Copy the prompt

Copied

Show me every item stored in the acme_support dataset.

Enrich and clean up

Copy the prompt

Copied

Run an improve pass over the support_tickets dataset.

Copy the prompt

Copied

Has the last enrichment run finished yet?

Copy the prompt

Copied

Forget the outdated 2024 roadmap dataset.

SEE HOW AUTH WORKS

Your users connect once. Their Cognee credentials stay vaulted, every call is scope-checked, and every action is logged.

1

Authorize

Your user connects

Cognee

once. We tie it to their identity and the meetings they approved — no shared bot account, no org-wide access

Who:

user ‘A’

when:

Once per user

access:

Limited to user

2

Store

Their

Cognee

token lives in a vault scoped to them. User A's meetings are never reachable by an agent acting for user B, even on the same connection

vault:

encrypted

scope:

per-user

tokens:

auto-refreshed

3

Resolve

When your agent calls a

Cognee

tool, we fetch the right token server-side. It never touches your agent, never appears in the LLM context, never shows up in your logs

speed:

~40ms

check:

before every call

seen by:

nobody

4

Audit

Every

Cognee

tool call is logged — who triggered it, which meeting was fetched, what came back. 90 days of history, tied to the user who authorized it

history:

90 days

export:

SIEM-ready

logged:

every call

Test other agents

See the same per-user auth pattern across other memory connectors.

No items found.

Why Scalekit

Secure your agent's access. Connectors ship in minutes

Other connector libraries treat auth as a demo afterthought. Scalekit starts with identity, scope enforcement, and audit. Connectors follow.

01.

Shared tokens break per-user analytics

A shared Cognee key looks fine in a demo. In production every recall, improve, and forget looks like one service account, and you cannot tell whose memory the agent touched. Scalekit resolves the credential of the actual user who triggered the agent, never a shared bot.

// shared key
audit → bot_service_account

// scalekit
audit → user_abc ✓

02.

Authentication is not authorization

03.

Multi-tenancy is architectural

04.

Cognee today. Ten connectors tomorrow.

“Our agents act across Salesforce, Gong, Google Drive, and more, on behalf of every customer. Scalekit behind the scenes meant we can keep adding tools without ever rebuilding how credentials or tool calling work.”

Venu Madhav Kattagoni

Head of Engineering / Von

FAQs

Frequently Asked Questions

Does the agent access Cognee as the user or through a shared key?

As the user. Scalekit resolves the credential of the person who triggered the agent at request time, so every recall, enrichment, and deletion in your audit trail is attributed to a real user, not a shared service account.

Where is the Cognee API key stored?

In an AES-256 encrypted vault with per-tenant namespacing. Keys are resolved at request time, never enter LLM context, and can be revoked from one dashboard.

Can I limit what the agent does in Cognee?

Yes. Filter by tool name in listScopedTools to expose only what you want, for example recall and list without improve or forget. Scalekit also enforces scope checks before every API call.

What happens when a user revokes access?

The credential is invalidated at the next tool call. The call fails closed, other users' connections are unaffected, and the revocation is logged in the audit chain.

Forget is permanent. What stops an agent from wiping memory?

Exclude cognee_forget from listScopedTools and the agent never sees the tool. If you do expose it, Scalekit still scope-checks every call before it reaches Cognee and logs exactly which user's agent deleted which dataset.

Cognee

Tools your memory agent reaches for on Cognee, scoped per user.