semantic-memory-fabric

name	semantic-memory-fabric
description	Store, retrieve, and evolve contextual and procedural knowledge using vector search, memory layers, and active forgetting.

Skill: Semantic Memory Fabric

Category: Agent Memory Priority: High

---

Description

This skill extends DevinOS memory beyond simple file-based entries into a semantic memory fabric. It stores contextual, procedural, and semantic knowledge in a searchable, layered structure, and supports active forgetting, self-correction, and retrieval-augmented generation.

Purpose

To give DevinOS a rich, long-term memory that can recall relevant experiences, apply knowledge across new contexts, and correct outdated memories without human intervention.

Trigger

Use this skill when:

• A task requires recalling similar past projects or decisions.
• You need to search across many memory entries by meaning rather than keyword.
• Long-term memory is growing and needs pruning or correction.
• You are building a retrieval-augmented workflow for complex tasks.

Context

• Existing memory entries from memory_manager.py.
• Vector database or embedding provider.
• Categorization scheme for memory layers (episodic, semantic, procedural).
• Policy for active forgetting and memory correction.
• Privacy and retention rules.

Workflow

1. Ingest memories. Read existing memory entries and convert them into structured, embedded documents.
2. Classify layers. Tag each memory as episodic (what happened), semantic (what it means), or procedural (how to do it).
3. Embed and store. Generate embeddings and store them in a vector database with metadata.
4. Retrieve semantically. At task start, query the fabric for relevant memories based on meaning, not just keywords.
5. Apply context. Use retrieved memories to inform decisions, avoid past mistakes, and reuse proven patterns.
6. Correct and forget. Periodically review memory for contradictions, outdated facts, or low-value entries. Update or remove them.
7. Learn continuously. After each task, add new learnings and link them to related skills and rules.

Examples

Good: Reuse a proven pattern

Scenario: The agent is starting a new project that needs authentication.

Agent Action:

1. Queries the semantic memory for "authentication patterns."
2. Finds a previous memory about using OAuth2 + PKCE for SPAs.
3. Reuses the proven pattern and updates the project's architecture.

Bad: Recall irrelevant old memories

Scenario: The agent retrieves every memory about "React" because the current task mentions React Native.

Agent Action:

1. Uses semantic search to distinguish React DOM from React Native.
2. Filters results by relevance score and metadata tags.

Anti-patterns

• Storing every minor detail without classification.
• Retrieving memories without relevance scoring.
• Never pruning or correcting outdated memory.
• Mixing sensitive and public memories without access controls.
• Relying on memory without verifying it against the current context.

Verification

• Memories are classified into layers.
• Embeddings are generated and stored in a searchable vector store.
• Retrieval returns relevant results for semantic queries.
• Active forgetting and correction are implemented.
• New memories are added after each task.
• Cross-skill references are used (Knowledge Distillation, Memory Manager, Knowledge Graph Integration).

Cross Skill References

• Knowledge Distillation: Extracting and generalizing lessons for memory.
• Memory Manager: Basic file-based memory entry management.
• Knowledge Graph Integration: Connecting memories as a graph of relationships.
• AI Engineering: Retrieval-augmented generation and embedding workflows.

References

• Mem0: https://github.com/mem0ai/mem0
• Chroma: https://www.trychroma.com/
• Pinecone: https://www.pinecone.io/
• Qdrant: https://qdrant.tech/
• Kage (memory-on-git): https://github.com/kage-memory