Skip to main content
skill CX Codex

cognee:store — Claude Code skill: what it does, how to install

cognee:store is a Claude Code skill that writes session entities, decisions and events to a Cognee knowledge graph through POST /api/v1/remember. Project agreements stay in the graph and come back on semantic search.

MIT ★ 328 updated 2026-10-29

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add coco-research/coco --skill cognee:store -a claude-code
Open on GitHub

What cognee:store does

The skill is the write path for a project's memory: entities, decisions, events, relationships and tasks go to Cognee in one request tagged with a dataset name. Each item is plain text in a fixed shape, such as ENTITY: {name} | TYPE: {person|team|system|module|org_unit|document}, and Cognee turns that into nodes, edges and embeddings.

The /cognee-store:update routine reads the conversation top to bottom, lists what is new and prints a summary per category. Then it waits for Y/n/adjust before packing everything into a temp file and posting it as one batch. Task status changes and events from mail or meetings are written straight away; fresh decisions and new relationships get proposed first.

Nothing is stored unless a Cognee server answers on http://localhost:8000. The routine opens with a /health check and points to cognee server start when that fails. A dataset for the project has to exist before the first write, and /cognee init creates it.

What it helps with

  • log an architecture decision into the project graph
  • flush everything learned in a session as one batch
  • track which tasks changed status during a conversation
  • record a dependency between two services
  • save a call summary with participants and outcomes

Example prompts for the agent

  • cognee store: we're validating JWT on every API endpoint
  • Run /cognee-store:update and write down what we decided this session
  • Remember in the graph that Alice leads the PlatformHub backend

How to install cognee:store

1Skills CLI (Vercel)

npx skills add coco-research/coco --skill cognee:store -a claude-code

2Manually: put the files in place

~/.claude/skills/cognee-store/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/cognee-store/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about cognee:store

How do I install cognee:store in Claude Code?

Run npx skills add coco-research/coco --skill cognee-store -a claude-code. The skill file lands at ~/.claude/skills/cognee-store/SKILL.md.

What does cognee:store do?

It writes entities, decisions, events, relationships and tasks into a Cognee knowledge graph over POST /api/v1/remember, so later searches can recall them.

What has to be running before I use it?

A Cognee server, by default on http://localhost:8000, plus a dataset for the project. The skill checks /health first and stops if the answer is not 200.

Source text

SKILL.md · MIT
---
name: cognee:store
description: "Use when the user says 'cognee store', 'push to cognee', 'save to graph', 'remember this' or 'log this decision', or when session decisions must be stored. Writes entities, decisions and events over POST /api/v1/remember."
---

# /cognee-store — Push Knowledge to the Graph

Stores structured knowledge into Cognee's knowledge graph. Functions as the write path for Coco's memory layer — maps entities, decisions, events, and relationships to graph nodes and edges with embeddings for later semantic retrieval.

## Quick Reference

```bash
COGNEE="${COGNEE_BASE_URL:-http://localhost:8000}"
DATASET="my-project"

# Store a text fact (auto-cognifies)
curl -s -X POST "$COGNEE/api/v1/remember" \
  -F "datasetName=$DATASET" \
  -F 'data={"entity": {"type": "decision", "text": "Use JWT for API auth", "date": "2026-06-30", "decided_by": "dana", "context": "Stateless, works with existing infra"}}' \
  -F "run_in_background=false" | jq .

# Store file-based knowledge
curl -s -X POST "$COGNEE/api/v1/remember" \
  -F "datasetName=$DATASET" \
  -F "data=@/path/to/decision-log.md" \
  -F "run_in_background=false" | jq .

# Cognify existing data (process + build graph)
curl -s -X POST "$COGNEE/api/v1/cognify" \
  -H "Content-Type: application/json" \
  -d '{"datasets": ["my-project"]}' | jq .
```

## Data Format

All knowledge is stored as text, structured for Cognee's graph extraction. Use these formats:

### Entities
```
ENTITY: {name} | TYPE: {person|team|system|module|org_unit|document}
DESCRIPTION: {one-line description}
METADATA: {key: value, ...}
```

### Decisions
```
DECISION: {text} | DATE: {YYYY-MM-DD}
DECIDED_BY: {name}
CONTEXT: {why this was decided, alternatives considered}
IMPACT: {what changes as a result}
```

### Events
```
EVENT: {title} | DATE: {YYYY-MM-DD} | TYPE: {meeting|call|email|milestone|deploy}
SUMMARY: {what happened}
PARTICIPANTS: {comma-separated names}
OUTCOMES: {decisions made, action items}
```

### Relationships
```
RELATIONSHIP: {entity_a} -> {entity_b} | TYPE: {member_of|owns|depends_on|reports_to|blocks|administers|scoped_to}
CONTEXT: {why this relationship exists}
```

### Tasks
```
TASK: {description} | STATUS: {open|in_progress|blocked|waiting|done|cancelled}
PRIORITY: {1 (highest) - 5 (lowest)}
ASSIGNED_TO: {name}
BLOCKED_BY: {task or entity reference}
```

## /cognee-store:update — End-of-Session Flush

**This is the most important command.** When invoked, the agent MUST thoroughly review the entire conversation and write everything learned to Cognee. This is a forcing function — do not skip anything.

### Procedure

### Step 1: Check Cognee availability

```bash
COGNEE="${COGNEE_BASE_URL:-http://localhost:8000}"
curl -s -o /dev/null -w "%{http_code}" "$COGNEE/health"
```

If not 200: "Cognee is not running. Start with `cognee server start`." → offer to use `/brain-update` instead.

### Step 2: Verify dataset exists

```bash
curl -s "$COGNEE/api/v1/datasets" | jq -r '.[].name'
```

If the project dataset doesn't exist: "No dataset found for this project. Run `/cognee init` first."

### Step 3: Scan the full conversation

Go through every message from top to bottom. Extract:

| Category | What to look for |
|----------|-----------------|
| **New entities** | Any person, team, role, system, module mentioned for the first time |
| **New relationships** | Connections discovered: X owns Y, A reports to B |
| **New decisions** | Anything decided, agreed, confirmed, resolved, or ruled out |
| **New events** | Meetings, calls, emails read, milestones, deployments |
| **New tasks** | Action items, to-dos, next steps, follow-ups |
| **Task updates** | Existing tasks that changed status |
| **Entity updates** | New info about existing entities |

### Step 4: Present summary

```
COGNEE STORE SUMMARY
====================
Dataset:        my-project

New entities:      3 (Alice Chen [person], PlatformHub [module], Auth Service [system])
New decisions:     2 (Use JWT for API auth, Rate-limit at gateway level)
New events:        1 (Architecture review call Jun 30)
New tasks:         4 (Set up JWT middleware, Configure rate limiter, ...)
Task updates:      2 (task #3 → blocked, task #5 → in_progress)
New relationships: 1 (Auth Service depends_on PlatformHub)
Entity updates:    1 (Alice Chen: added backend lead role)

Total items to store: 13
```

### Step 5: Wait for confirmation

Ask: **"Write all to Cognee? [Y/n/adjust]"**

### Step 6: Execute writes

On confirmation, format each item according to the data formats above and send as a single batch:

```bash
COGNEE="${COGNEE_BASE_URL:-http://localhost:8000}"

# Build the payload as a multiline text document
cat > /tmp/cognee-store-batch.txt << 'STORE_EOF'
ENTITY: Alice Chen | TYPE: person
DESCRIPTION: Backend lead on PlatformHub
METADATA: {role: "backend lead", team: "Engineering"}

ENTITY: PlatformHub | TYPE: module
DESCRIPTION: Central platform for managing external access

ENTITY: Auth Service | TYPE: system
DESCRIPTION: Authentication and authorization service

DECISION: Use JWT for API auth | DATE: 2026-06-30
DECIDED_BY: dana
CONTEXT: Stateless, works with existing infrastructure. Considered session tokens but JWT more scalable.
IMPACT: All API endpoints will validate JWT tokens

DECISION: Rate-limit at gateway level | DATE: 2026-06-30
DECIDED_BY: dana
CONTEXT: Prefer gateway-level rate limiting over per-service to avoid duplication
IMPACT: API gateway configuration needs updating

EVENT: Architecture review call | DATE: 2026-06-30 | TYPE: call
SUMMARY: Reviewed authentication and rate-limiting architecture
PARTICIPANTS: dana, alex
OUTCOMES: JWT chosen for auth, rate-limiting at gateway

RELATIONSHIP: Auth Service -> PlatformHub | TYPE: depends_on
CONTEXT: Auth service validates tokens before requests reach PlatformHub

TASK: Set up JWT middleware | STATUS: open
PRIORITY: 1
ASSIGNED_TO: Alice Chen

TASK: Configure rate limiter at gateway | STATUS: open
PRIORITY: 2
ASSIGNED_TO: Alice Chen

TASK: Update API docs with auth headers | STATUS: open
PRIORITY: 3

TASK: Add monitoring for rate-limit hits | STATUS: open
PRIORITY: 4
STORE_EOF

# Send batch
curl -s -X POST "$COGNEE/api/v1/remember" \
  -F "datasetName=$DATASET" \
  -F "data=@/tmp/cognee-store-batch.txt" \
  -F "run_in_background=false" | jq .

rm /tmp/cognee-store-batch.txt
```

### Step 7: Report

```
COGNEE STORE COMPLETE
=====================
Dataset:    my-project
Stored:     13 items (3 entities, 2 decisions, 1 event, 4 tasks, 2 updates, 1 relationship)
Cognified:  yes
Graph:      updated with new nodes and edges

Recall with: /cognee-recall "what did we decide about authentication"
```

## Behavior Rules

### Auto-write (no confirmation needed)
- Entity sync from external sources (MCP, APIs)
- Task status updates
- Event logging from emails and meetings
- Changelog entries

### Confirm-write (propose to user first)
- New decisions
- New relationships between entities
- Bulk end-of-session flush (`/cognee-store:update`)

### Inline store (single items during conversation)
When a decision is made or important info surfaces mid-conversation, offer a lightweight store:

```
> "Should I store this decision in Cognee? [store / skip]"
```

If "store": format as single item and send via `/remember`.

### Dedup
Before storing, check if similar content already exists by doing a quick search:

```bash
curl -s -X POST "$COGNEE/api/v1/search" \
  -H "Content-Type: application/json" \
  -d "{\"query\": \"$SEARCH_TEXT\", \"datasets\": [\"$DATASET\"], \"search_type\": \"FEELING_LUCKY\", \"top_k\": 5}" | jq .
```

If high-confidence match found (>80% similarity), note it and skip: "Similar content already exists in graph. Skipping duplicate."

### Batch efficiency
Group all items into a single `/remember` call rather than sending individual requests. Cognee processes the batch and builds graph connections between items automatically.

## Cognee vs Brain: When to use which for storing

| Scenario | Use |
|----------|-----|
| Quick local decision log | Brain (SQLite, instant) |
| Cross-project entity linking | Cognee (graph edges span datasets) |
| Semantic search needed later | Cognee (embeddings enable fuzzy recall) |
| Offline / no Cognee running | Brain (zero dependencies) |
| Session context for auto-recall | Cognee (session-aware search) |
| Both (belt and suspenders) | Store to both |

© coco-research · MIT · coco-research/coco

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set82

The whole set →
pmstudio-sync The pmstudio-sync skill turns changes in source files into proposed updates for linked PRDs, decks, and notes. It waits for approval before editing. CX Codex +1 ★ 328repo stars agent-lightning A reference skill for Microsoft's Agent Lightning: instrument an agent, collect traces, then run reinforcement learning or prompt tuning on top of them. CX Codex +1 ★ 328repo stars sync-init sync-init automates project background sync every 2 hours: monitors Outlook emails, checks watched folders for changes, and refreshes documents via Claude CLI. CX Codex +1 ★ 328repo stars test Runs the complete test cycle: coverage analysis, test generation, and regression validation. Call it to fill coverage gaps or verify the test suite runs end-to-end. CX Codex +1 ★ 328repo stars gsd-user-profiler The gsd-user-profiler subagent reads developer session messages and builds a behavioral profile with ratings, confidence levels, and evidence. A profiling workflow can launch it for analysis. CX Codex ★ 328repo stars mcp-specialist mcp-specialist — a subagent for building and configuring MCP servers in Claude Code. Handles architecture design, transport layer implementation, tool and resource setup, and connection troubleshooting against the MCP 2025-06-18 spec. CX Codex ★ 328repo stars gradient-text-sweep gradient-text-sweep guides Claude Code in animating gradients inside text via background-clip: text and GSAP. Fits title card sweeps, karaoke word reveals, and hue crossfades. CX Codex +1 ★ 328repo stars ai-marketing-videos ai-marketing-videos is a Claude Code skill for product promos, ad creatives, and explainers using video and voice models. It combines scenes with a voice track. CX Codex +1 ★ 328repo stars

Project sponsors

Companies that keep this analytics open