Skip to content
Back to search

cognee

MarketplaceWorks with Claude CodeGitHubIncomplete

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

Its scripts were only partly scanned.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/topoteretes/cognee-integrations with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/topoteretes/cognee-integrations'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/topoteretes--cognee-integrations/badge.svg)](/listings/topoteretes--cognee-integrations)

HTML

<a href="/listings/topoteretes--cognee-integrations"><img src="/api/listings/topoteretes--cognee-integrations/badge.svg" alt="findsafeskills safety rating" /></a>

Install

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 25 lines
  1. {
  2. "name": "cognee",
  3. "owner": {
  4. "name": "Cognee",
  5. "url": "https://github.com/topoteretes"
  6. },
  7. "metadata": {
  8. "description": "Cognee's plugins for Claude Code: persistent knowledge-graph memory.",
  9. "version": "1.0.0"
  10. },
  11. "plugins": [
  12. {
  13. "name": "cognee-memory",
  14. "source": "./integrations/claude-code",
  15. "description": "Persistent memory for Claude Code, built on Cognee's knowledge graph. Captures your prompts, tool calls and answers, recalls what's relevant on every prompt, and carries decisions and lessons into later sessions. Runs locally or on Cognee Cloud.",
  16. "version": "1.8.9",
  17. "author": {
  18. "name": "Cognee"
  19. },
  20. "homepage": "https://github.com/topoteretes/cognee-integrations/tree/main/integrations/claude-code",
  21. "keywords": ["memory", "knowledge-graph", "cognee", "reasoning", "session", "persistent-memory"],
  22. "category": "memory"
  23. }
  24. ]
  25. }
README.md · README · 296 lines
  1. <div align="center">
  2. <a href="https://www.cognee.ai">
  3. <img src="https://raw.githubusercontent.com/topoteretes/cognee-integrations/main/assets/cognee-logo.svg" alt="Cognee" width="260">
  4. </a>
  5. <br />
  6. Cognee Integrations - AI Memory for Your Agent Framework
  7. <p align="center">
  8. <a href="https://www.youtube.com/watch?v=8hmqS2Y5RVQ&t=13s">Demo</a>
  9. .
  10. <a href="https://docs.cognee.ai/">Docs</a>
  11. .
  12. <a href="https://cognee.ai">Learn More</a>
  13. ·
  14. <a href="https://discord.gg/NQPKmU5CCg">Join Discord</a>
  15. ·
  16. <a href="https://www.reddit.com/r/AIMemory/">Join r/AIMemory</a>
  17. .
  18. <a href="https://github.com/topoteretes/cognee">Core Repo</a>
  19. </p>
  20. [![GitHub forks](https://img.shields.io/github/forks/topoteretes/cognee-integrations.svg?style=social&label=Fork&maxAge=2592000)](https://GitHub.com/topoteretes/cognee-integrations/network/)
  21. [![GitHub stars](https://img.shields.io/github/stars/topoteretes/cognee-integrations.svg?style=social&label=Star&maxAge=2592000)](https://GitHub.com/topoteretes/cognee-integrations/stargazers/)
  22. [![Downloads](https://static.pepy.tech/badge/cognee)](https://pepy.tech/project/cognee)
  23. [![License](https://img.shields.io/github/license/topoteretes/cognee-integrations?colorA=00C586&colorB=000000)](https://github.com/topoteretes/cognee-integrations/blob/main/LICENSE)
  24. [![Contributors](https://img.shields.io/github/contributors/topoteretes/cognee-integrations?colorA=00C586&colorB=000000)](https://github.com/topoteretes/cognee-integrations/graphs/contributors)
  25. <a href="https://github.com/sponsors/topoteretes"><img src="https://img.shields.io/badge/Sponsor-❤️-ff69b4.svg" alt="Sponsor"></a>
  26. </div>
  27. # Cognee Integrations
  28. Monorepo for all Cognee-owned integration packages. Each integration gives an agent
  29. framework (Strands, CrewAI, LangGraph, Google ADK, …) a persistent **memory layer**
  30. backed by [cognee](https://github.com/topoteretes/cognee): a permanent knowledge graph
  31. plus a fast session cache.
  32. ## Available Integrations
  33. Install these from their public registries — you do **not** need to clone this monorepo to use them.
  34. | Framework | Package | Install |
  35. |---|---|---|
  36. | Strands | `cognee-integration-strands` | `pip install cognee-integration-strands` |
  37. | CrewAI | `cognee-integration-crewai` | `pip install cognee-integration-crewai` |
  38. | LangGraph | `cognee-integration-langgraph` | `pip install cognee-integration-langgraph` |
  39. | Google ADK | `cognee-integration-google-adk` | `pip install cognee-integration-google-adk` |
  40. | Claude Agent SDK | `cognee-integration-claude` | `pip install cognee-integration-claude` |
  41. | Hermes Agent | `cognee-integration-hermes-agent` | `pip install cognee-integration-hermes-agent` |
  42. | OpenClaw | `@cognee/cognee-openclaw` | `npm install @cognee/cognee-openclaw` or install from clawhub.ai|
  43. | n8n | `n8n-nodes-cognee` | install via n8n community nodes |
  44. | Dify (Cloud) | `cognee` | install from the Dify marketplace |
  45. | Dify (self-hosted) | `cognee-sdk` | install from the Dify marketplace |
  46. Each integration has its own `README.md` under `integrations/<name>/` with the full tool
  47. reference and runnable examples. The table above is generated from
  48. [`integrations/inventory.yml`](integrations/inventory.yml) — see it for ownership,
  49. versions, and compatible cognee ranges.
  50. ### Chat bots & editor
  51. Memory apps and editor tooling that talk to a running **cognee server**
  52. (`COGNEE_BASE_URL`) over its HTTP API — no in-process cognee. Each lives under
  53. `integrations/<name>/` with a runnable example and its own `README.md`.
  54. | Integration | Package | What it does |
  55. |---|---|---|
  56. | Chat-memory core | `cognee-integration-chat-memory` | the shared `ChatMemoryAdapter` every cognee chat bot builds on |
  57. | Telegram | `cognee-integration-telegram` | each chat is a memory; `/ask` with cited message links |
  58. | Slack | `cognee-integration-slack` | per-channel memory; `@cognee` / `/recall` cited answers |
  59. | Web chat widget | `cognee-integration-web-widget` | one-script-tag embeddable widget + "ask our docs" |
  60. | Second brain | `cognee-integration-second-brain` | cross-transport personal memory (Telegram + web), `/link` identity merge |
  61. | VS Code | `cognee-vscode` | remember/recall + "ask my project memory" with source-file citations |
  62. ### Community integrations
  63. Maintained by the community in their own repos — tracked here in
  64. [`integrations/inventory.yml`](integrations/inventory.yml) so they're easy to find.
  65. | Integration | Package | Install |
  66. |---|---|---|
  67. | [Pi coding agent](https://github.com/kerryhatcher/pi-cognee) | `@kerryhatcher/pi-cognee` | `pi install npm:@kerryhatcher/pi-cognee` |
  68. ## Claude Code Quickstart
  69. The Claude Code integration is a **plugin** — it gives Claude Code persistent memory
  70. across sessions with no code to write. It auto-captures your prompts, tool traces, and
  71. responses, and auto-recalls relevant context on every prompt.
  72. **Requirements:** any Python 3.9+ as `python3` on PATH runs the hooks (they are
  73. stdlib-only HTTP clients; macOS's Xcode Command Line Tools Python is enough). Local mode
  74. additionally needs a Python 3.10–3.14 installed somewhere on the machine: the plugin
  75. builds its own virtualenv for the Cognee server from an interpreter it finds (via
  76. [uv](https://docs.astral.sh/uv/) if you already have it, else the stdlib `venv`) and
  77. installs the exact pinned `cognee` release into it. It never downloads installers or
  78. interpreters; with no 3.10+ Python available it says so at session start. The SDK
  79. packages in the table above import cognee in-process and need Python 3.10+ (3.12+ for
  80. Dify, 3.13+ for the Claude Agent SDK); see
  81. [`integrations/CONFIGURATION.md`](integrations/CONFIGURATION.md#python-version-requirements).
  82. **1. Install the Claude Code plugin**
  83. Run these slash commands directly in the Claude Code chat:
  84. ```
  85. /plugin marketplace add topoteretes/cognee-integrations
  86. /plugin install cognee-memory@cognee
  87. ```
  88. **2. Configure your LLM key**
  89. In local mode (the default), the plugin bootstraps a local Cognee API on
  90. `http://localhost:8011`. Cognee extracts knowledge with an LLM, so set `LLM_API_KEY`
  91. **once** in `~/.cognee/.env` (shared by the Claude Code and Codex plugins) — one
  92. paste, no editor needed:
  93. ```bash
  94. mkdir -p ~/.cognee
  95. cat >> ~/.cognee/.env <<'EOF'
  96. LLM_API_KEY="sk-..."
  97. EOF
  98. chmod 600 ~/.cognee/.env
  99. ```
  100. A plain `export` in the launching shell also works and overrides the file. Re-pasting
  101. the block with a new value is safe — the last value wins.
  102. To target Cognee Cloud or a remote server instead, set `COGNEE_BASE_URL` and
  103. `COGNEE_API_KEY` there. The file may hold **both modes' variables at once** — cloud
  104. wins by default, and `export COGNEE_BACKEND=local` (or `=cloud`) flips a single
  105. terminal without touching the file; see
  106. [Which mode wins, and how to switch](integrations/claude-code/README.md#which-mode-wins-and-how-to-switch).
  107. On startup you should see a **"Cognee Memory Connected"** message.
  108. **3. Use Claude Code as usual**
  109. Memory is captured and recalled automatically — no extra steps. You can also invoke the
  110. skills explicitly:
  111. ```
  112. /cognee-memory:cognee-remember # store something now
  113. /cognee-memory:cognee-search # query memory
  114. /cognee-memory:cognee-sync # persist the session into the graph
  115. ```
  116. For full configuration (datasets, sessions, sync watchers, cloud mode), see
  117. [`integrations/claude-code/README.md`](integrations/claude-code/README.md).
  118. > **Using an agent framework instead?** The Python SDK integrations (Strands, CrewAI,
  119. > LangGraph, Google ADK, Claude Agent SDK) follow a `pip install` →
  120. > set `LLM_API_KEY` → attach `cognee_tools()` pattern. See each integration's README
  121. > under `integrations/<name>/` for a runnable example.
  122. ### Two memory tiers
  123. Built on cognee v1.0, the integrations share the same two tiers:
  124. - **Permanent knowledge graph** — durable memory that survives across sessions.
  125. - **Session cache** — a cheap per-session cache (no graph extraction up front) that is
  126. promoted into the permanent graph on sync (`/cognee-memory:cognee-sync`, or
  127. `cognee.improve(session_ids=[...])` in the SDK integrations).
  128. ## Using the Python Integrations
  129. Every Python integration installs from PyPI and follows the same shape: **install →
  130. set `LLM_API_KEY` → build the cognee tools → pass them to your agent.** The only thing
  131. that differs per framework is the import line and how you construct the agent.
  132. ```bash
  133. pip install cognee-integration-strands # or -crewai, -langgraph, -google-adk, -claude
  134. export LLM_API_KEY="sk-..." # cognee extracts knowledge with an LLM
  135. ```
  136. The tools come in two styles depending on the integration's version:
  137. | Framework | Package | Build the tools with | Tools |
  138. |---|---|---|---|
  139. | Strands | `cognee-integration-strands` | `cognee_tools(session_id=None)` | `remember`, `recall` |
  140. | Claude Agent SDK | `cognee-integration-claude` | `cognee_tools(session_id=None)` | `remember`, `recall` |
  141. | CrewAI | `cognee-integration-crewai` | `from … import add_tool, search_tool` | `add_tool`, `search_tool` |
  142. | Google ADK | `cognee-integration-google-adk` | `from … import add_tool, search_tool` | `add_tool`, `search_tool` |
  143. | LangGraph | `cognee-integration-langgraph` | `get_sessionized_cognee_tools(user_id)` | `add_tool`, `search_tool` |
  144. **`cognee_tools()` style** (cognee v1.0 — Strands, Claude Agent SDK). Writes go to the
  145. permanent graph; pass `session_id=...` to use the session cache instead:
  146. ```python
  147. from cognee_integration_strands import cognee_tools
  148. from strands import Agent
  149. from strands.models.openai import OpenAIModel
  150. agent = Agent(model=OpenAIModel(...), tools=cognee_tools())
  151. agent("Remember that we signed a contract with Meditech Solutions for £1.2M.")
  152. print(agent("What is the value of the Meditech Solutions contract?"))
  153. ```
  154. **`add_tool` / `search_tool` style** (CrewAI, Google ADK, LangGraph). Here you also ingest
  155. source documents yourself with `cognee.add(...)` + `cognee.cognify()` before searching:
  156. ```python
  157. import cognee
  158. from cognee_integration_crewai import add_tool, search_tool # CrewAI / Google ADK
  159. from crewai import Agent
  160. await cognee.add("Meditech Solutions — healthcare industry, contract worth £1.2M.")
  161. await cognee.cognify() # build the knowledge graph
  162. agent = Agent(role="Analyst", goal="…", backstory="…", tools=[add_tool, search_tool])
  163. print(agent.kickoff("Which contracts are in the healthcare industry?"))
  164. ```
  165. LangGraph is the same style but builds its tools per user:
  166. `add_tool, search_tool = get_sessionized_cognee_tools("user-1")`.
  167. Each integration's `README.md` under `integrations/<name>/` has a complete runnable
  168. example (`examples/`) and the full tool reference.
  169. ## Structure
  170. Each integration lives under `integrations/<name>/` and is an independently publishable package.
  171. ```
  172. integrations/
  173. openclaw/ -> @openclaw/memory-cognee (npm)
  174. claude-code/ -> Cognee plugin for Claude Code
  175. codex/ -> Cognee plugin marketplace for Codex
  176. antigravity/ -> Cognee plugin for Antigravity
  177. cursor/ -> Cognee plugin for Cursor (hooks + skills)
  178. ```
  179. ## Adding a New Integration
  180. ### Python integrations
  181. _(Template coming soon. For now, follow the TypeScript pattern below and adapt for Python with `pyproject.toml`.)_
  182. ### TypeScript/Node integrations (e.g., OpenClaw plugins)
  183. 1. Create `integrations/<name>/` with `package.json`, entry file, and plugin manifest
  184. 2. Follow the target platform's plugin conventions
  185. 3. Add an entry to `integrations/inventory.yml`
  186. CI auto-detects new integrations by language (Python via `pyproject.toml`, TypeScript via `package.json`) — no workflow edits needed.
  187. ## Development
  188. Each integration is developed independently with its own toolchain:
  189. ```bash
  190. # Python integrations
  191. cd integrations/<name>
  192. uv sync --dev
  193. uv run pytest tests/ -v
  194. uv run ruff check .
  195. # TypeScript integrations
  196. cd integrations/<name>
  197. npm install
  198. npx tsc --noEmit
  199. ```
  200. ## Version Pinning Policy
  201. 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.
  202. When a new `cognee` version is released:
  203. 1. Update the bounds in affected integrations
  204. 2. Run tests to verify compatibility
  205. 3. Bump the integration version
  206. 4. Publish the updated package
  207. ## Publishing
  208. Each integration is published independently via tag-per-package:
  209. ```bash
  210. # TypeScript: publishes to npm
  211. git tag openclaw-v2026.2.4 && git push --tags
  212. # Python (when added): publishes to PyPI
  213. # git tag <name>-v<version> && git push --tags
  214. ```
  215. The `publish.yml` workflow parses the tag, runs tests, and publishes to the appropriate registry.
  216. ## CI
  217. - **Lint**: Ruff on every PR across all Python integrations
  218. - **Tests**: Auto-detects changed integrations and runs the right test suite (pytest for Python, tsc for TypeScript)
  219. - **Pin check**: Validates bounded `cognee` dependencies in Python integrations
  220. - **Publish**: Tag-triggered per-package publishing to PyPI or npm
  221. ## Inventory
  222. `integrations/inventory.yml` tracks all known integrations with ownership, migration status, package names, and version info. Update it when adding or migrating integrations.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.