PluginBench
Skill
Fail
Audit score 45

hindsight-docs

vectorize-io/hindsight

Complete technical documentation for Hindsight biomimetic memory system for AI agents.

What is hindsight-docs?

Hindsight is a biomimetic memory system that enables AI agents to retain, recall, and reflect on information. Use this skill to learn the architecture, APIs, configuration, deployment options, and best practices for integrating Hindsight into your agent workflows.

  • Access complete API documentation for retain/recall/reflect operations
  • Learn memory bank configuration and disposition settings
  • Review deployment guides for Docker, Kubernetes, and pip installations
  • Explore SDK integrations for Python, Node.js, Rust, and CLI
  • Understand retrieval strategies: semantic, BM25, graph, and temporal search
  • Find best practices for missions, tags, content formats, and anti-patterns

How to install hindsight-docs

npx skills add https://github.com/vectorize-io/hindsight --skill hindsight-docs
Claude Code
Cursor
Windsurf
Cline

How to use hindsight-docs

  1. 1.Start with references/best-practices.md to understand missions, tags, and anti-patterns
  2. 2.Use the Glob tool to find documentation by pattern (e.g., references/developer/api/*.md)
  3. 3.Use the Grep tool to search for specific concepts (disposition, graph retrieval, environment variables)
  4. 4.Read full documentation files from references/developer/api/ for core operations
  5. 5.Review references/sdks/ for language-specific integration examples
  6. 6.Consult references/changelog/ for version history and breaking changes

Use cases

Good for
  • Integrating persistent memory into multi-turn agent conversations
  • Setting up semantic and graph-based memory retrieval for context awareness
  • Configuring disposition-aware reasoning with skepticism, literalism, and empathy traits
  • Deploying Hindsight API server in production environments
  • Debugging memory operations and optimizing retrieval performance
Who it's for
  • AI agent developers building memory-augmented systems
  • Backend engineers deploying Hindsight infrastructure
  • ML engineers optimizing retrieval and reasoning pipelines
  • DevOps teams managing Hindsight in Kubernetes or Docker
  • Researchers exploring biomimetic memory architectures

hindsight-docs FAQ

Where do I start learning Hindsight?

Read references/best-practices.md first—it covers practical rules for missions, tags, content format, and anti-patterns before diving into API details.

How do I find documentation on a specific topic?

Use the Glob tool to search by pattern (e.g., references/**/*python*.md) or the Grep tool to search for keywords like 'disposition' or 'graph retrieval' within the references/ directory.

What are the four retrieval strategies Hindsight supports?

Semantic search, BM25 (keyword-based), graph-based retrieval, and temporal search—all run in parallel during recall operations.

How do I handle multi-turn conversations?

Use the same document_id for related messages in a conversation; Hindsight will upsert (update or insert) on the same ID to evolve the memory.

What deployment options are available?

Hindsight supports Docker, Kubernetes (with Helm), and pip installation; configuration uses HINDSIGHT_API_* environment variables and runs database migrations automatically on startup.

Full instructions (SKILL.md)

Source of truth, from vectorize-io/hindsight.


name: hindsight-docs description: Complete Hindsight documentation for AI agents. Use this to learn about Hindsight architecture, APIs, configuration, and best practices.

Hindsight Documentation Skill

Complete technical documentation for Hindsight - a biomimetic memory system for AI agents.

When to Use This Skill

Use this skill when you need to:

  • Understand Hindsight architecture and core concepts
  • Learn about retain/recall/reflect operations
  • Configure memory banks and dispositions
  • Set up the Hindsight API server (Docker, Kubernetes, pip)
  • Integrate with Python/Node.js/Rust SDKs
  • Understand retrieval strategies (semantic, BM25, graph, temporal)
  • Debug issues or optimize performance
  • Review API endpoints and parameters

Documentation Structure

All documentation is in references/ organized by category:

references/
├── best-practices.md # START HERE — missions, tags, formats, anti-patterns
├── faq.md            # Common questions and decisions
├── changelog/        # Release history and version changes (index.md + integrations/)
├── openapi.json      # Full OpenAPI spec — endpoint schemas, request/response models
├── developer/
│   ├── api/          # Core operations: retain, recall, reflect, memory banks
│   └── *.md          # Architecture, configuration, deployment, performance
└── sdks/
    ├── *.md          # Python, Node.js, CLI, embedded
    └── integrations/ # Framework and tool integrations

How to Find Documentation

1. Find Files by Pattern (use Glob tool)

# Core API operations
references/developer/api/*.md

# SDK documentation
references/sdks/*.md
references/sdks/integrations/*.md

# Find specific topics
references/**/configuration.md
references/**/*python*.md
references/**/*deployment*.md

2. Search Content (use Grep tool)

# Search for concepts
pattern: "disposition"        # Memory bank configuration
pattern: "graph retrieval"    # Graph-based search
pattern: "helm install"       # Kubernetes deployment
pattern: "document_id"        # Document management
pattern: "HINDSIGHT_API_"     # Environment variables

# Search in specific areas
path: references/developer/api/
pattern: "POST /v1"           # Find API endpoints

path: references/sdks/
pattern: "def |async def "    # Find Python examples

3. Read Full Documentation (use Read tool)

references/developer/api/retain.md
references/sdks/python.md
references/sdks/integrations/litellm.md

Start Here: Best Practices

Before reading API docs, read the best practices guide. It covers practical rules for missions, tags, content format, observation scopes, and anti-patterns — the fastest way to integrate correctly.

references/best-practices.md

Key Concepts

  • Memory Banks: Isolated memory stores (one per user/agent)
  • Retain: Store memories (auto-extracts facts/entities/relationships)
  • Recall: Retrieve memories (4 parallel strategies: semantic, BM25, graph, temporal)
  • Reflect: Disposition-aware reasoning using memories
  • document_id: Groups messages in a conversation (upsert on same ID)
  • Dispositions: Skepticism, literalism, empathy traits (1-5) affecting reflect
  • Mental Models: Consolidated knowledge synthesized from facts

Notes

  • Code examples are inlined from working examples
  • Configuration uses HINDSIGHT_API_* environment variables
  • Database migrations run automatically on startup
  • Multi-bank queries require client-side orchestration
  • Use document_id for conversation evolution (same ID = upsert)

Auto-generated from hindsight-docs/docs/ and hindsight-docs/docs-integrations/. Run ./scripts/generate-docs-skill.sh to update.