topoteretes/cognee-integrations

Cognee Integrations - AI Memory for Your Agent Framework

Demo . Docs . Learn More · Join Discord · Join r/AIMemory . Core Repo

Cognee Integrations

Monorepo for all Cognee-owned integration packages. Each integration gives an agent framework (Strands, CrewAI, LangGraph, Google ADK, …) a persistent memory layer backed by cognee: a permanent knowledge graph plus a fast session cache.

Available Integrations

Install these from their public registries — you do not need to clone this monorepo to use them.

Each integration has its own README.md under integrations/<name>/ with the full tool reference and runnable examples. The table above is generated from integrations/inventory.yml — see it for ownership, versions, and compatible cognee ranges.

Chat bots & editor

Memory apps and editor tooling that talk to a running cognee server (COGNEE_BASE_URL) over its HTTP API — no in-process cognee. Each lives under integrations/<name>/ with a runnable example and its own README.md.

Quickstart

The Claude Code integration is a plugin — it gives Claude Code persistent memory across sessions with no code to write. It auto-captures your prompts, tool traces, and responses, and auto-recalls relevant context on every prompt.

1. Install the plugin

Run these slash commands directly in the Claude Code chat:

/plugin marketplace add topoteretes/cognee-integrations
/plugin install cognee-memory@cognee

2. Configure your LLM key

In local mode (the default), the plugin bootstraps a local Cognee API on http://localhost:8011. Cognee extracts knowledge with an LLM, so set LLM_API_KEY once in ~/.cognee/.env (shared by the Claude Code and Codex plugins) — one paste, no editor needed:

mkdir -p ~/.cognee
cat >> ~/.cognee/.env <<'EOF'
LLM_API_KEY="sk-..."
EOF
chmod 600 ~/.cognee/.env

A plain export in the launching shell also works and overrides the file. Re-pasting the block with a new value is safe — the last value wins.

To target Cognee Cloud or a remote server instead, set COGNEE_BASE_URL and COGNEE_API_KEY there. On startup you should see a "Cognee Memory Connected" message.

3. Use Claude Code as usual

Memory is captured and recalled automatically — no extra steps. You can also invoke the skills explicitly:

/cognee-memory:cognee-remember   # store something now
/cognee-memory:cognee-search     # query memory
/cognee-memory:cognee-sync       # persist the session into the graph

For full configuration (datasets, sessions, sync watchers, cloud mode), see integrations/claude-code/README.md.

Using an agent framework instead? The Python SDK integrations (Strands, CrewAI, LangGraph, Google ADK, Claude Agent SDK) follow a pip install → set LLM_API_KEY → attach cognee_tools() pattern. See each integration's README under integrations/<name>/ for a runnable example.

Two memory tiers

Built on cognee v1.0, the integrations share the same two tiers:

• Permanent knowledge graph — durable memory that survives across sessions.
• Session cache — a cheap per-session cache (no graph extraction up front) that is promoted into the permanent graph on sync (/cognee-memory:cognee-sync, or cognee.improve(session_ids=[...]) in the SDK integrations).

Using the Python Integrations

Every Python integration installs from PyPI and follows the same shape: install → set LLM_API_KEY → build the cognee tools → pass them to your agent. The only thing that differs per framework is the import line and how you construct the agent.

pip install cognee-integration-strands       # or -crewai, -langgraph, -google-adk, -claude
export LLM_API_KEY="sk-..."                   # cognee extracts knowledge with an LLM

The tools come in two styles depending on the integration's version:

cognee_tools() style (cognee v1.0 — Strands, Claude Agent SDK). Writes go to the permanent graph; pass session_id=... to use the session cache instead:

from cognee_integration_strands import cognee_tools
from strands import Agent
from strands.models.openai import OpenAIModel

agent = Agent(model=OpenAIModel(...), tools=cognee_tools())
agent("Remember that we signed a contract with Meditech Solutions for £1.2M.")
print(agent("What is the value of the Meditech Solutions contract?"))

add_tool / search_tool style (CrewAI, Google ADK, LangGraph). Here you also ingest source documents yourself with cognee.add(...) + cognee.cognify() before searching:

import cognee
from cognee_integration_crewai import add_tool, search_tool   # CrewAI / Google ADK
from crewai import Agent

await cognee.add("Meditech Solutions — healthcare industry, contract worth £1.2M.")
await cognee.cognify()                                        # build the knowledge graph

agent = Agent(role="Analyst", goal="…", backstory="…", tools=[add_tool, search_tool])
print(agent.kickoff("Which contracts are in the healthcare industry?"))

LangGraph is the same style but builds its tools per user: add_tool, search_tool = get_sessionized_cognee_tools("user-1").

Each integration's README.md under integrations/<name>/ has a complete runnable example (examples/) and the full tool reference.

Structure

Each integration lives under integrations/<name>/ and is an independently publishable package.

integrations/
  openclaw/           -> @openclaw/memory-cognee (npm)
  claude-code/        -> Cognee plugin for Claude Code
  codex/              -> Cognee plugin marketplace for Codex

Adding a New Integration

Python integrations

(Template coming soon. For now, follow the TypeScript pattern below and adapt for Python with pyproject.toml.)

TypeScript/Node integrations (e.g., OpenClaw plugins)

1. Create integrations/<name>/ with package.json, entry file, and plugin manifest
2. Follow the target platform's plugin conventions
3. Add an entry to integrations/inventory.yml

CI auto-detects new integrations by language (Python via pyproject.toml, TypeScript via package.json) — no workflow edits needed.

Development

Each integration is developed independently with its own toolchain:

# Python integrations
cd integrations/<name>
uv sync --dev
uv run pytest tests/ -v
uv run ruff check .

# TypeScript integrations
cd integrations/<name>
npm install
npx tsc --noEmit

Version Pinning Policy

Python integrations must pin the cognee dependency with a bounded range (e.g., cognee>=0.5.1,<0.6.0). This is enforced by CI via scripts/check_version_pins.py. TypeScript integrations that talk to Cognee via HTTP API are exempt from package pinning but should document compatible Cognee server versions.

When a new cognee version is released:

1. Update the bounds in affected integrations
2. Run tests to verify compatibility
3. Bump the integration version
4. Publish the updated package

Publishing

Each integration is published independently via tag-per-package:

# TypeScript: publishes to npm
git tag openclaw-v2026.2.4 && git push --tags

# Python (when added): publishes to PyPI
# git tag <name>-v<version> && git push --tags

The publish.yml workflow parses the tag, runs tests, and publishes to the appropriate registry.

CI

• Lint: Ruff on every PR across all Python integrations
• Tests: Auto-detects changed integrations and runs the right test suite (pytest for Python, tsc for TypeScript)
• Pin check: Validates bounded cognee dependencies in Python integrations
• Publish: Tag-triggered per-package publishing to PyPI or npm

Inventory

integrations/inventory.yml tracks all known integrations with ownership, migration status, package names, and version info. Update it when adding or migrating integrations.