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?

This skill provides comprehensive reference documentation for Hindsight, a memory architecture for AI agents. Use it to understand core concepts (retain/recall/reflect), configure memory banks, deploy the API server, integrate SDKs, and review best practices and cookbook examples.

  • Access complete API documentation for retain, recall, reflect, and memory bank operations
  • Learn Hindsight architecture, core concepts, and retrieval strategies (semantic, BM25, graph, temporal)
  • Review configuration options and environment variables for API server setup
  • Find SDK integration guides for Python, Node.js, Rust, and CLI
  • Explore deployment instructions for Docker, Kubernetes, and pip installations
  • Browse cookbook recipes and full application examples

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 by reading references/best-practices.md for practical integration rules and anti-patterns
  2. 2.Use the Glob tool to find documentation by pattern (e.g., references/developer/api/*.md for core operations)
  3. 3.Use the Grep tool to search for specific concepts (e.g., 'disposition', 'graph retrieval', 'HINDSIGHT_API_')
  4. 4.Read full documentation files using the Read tool (e.g., references/sdks/python.md for SDK integration)
  5. 5.Consult references/openapi.json for complete endpoint schemas and request/response models
  6. 6.Browse references/cookbook/recipes/ and references/cookbook/applications/ for usage patterns and examples

Use cases

Good for
  • Integrating Hindsight memory into a Python or Node.js agent application
  • Configuring memory banks and dispositions for multi-user or multi-agent scenarios
  • Deploying Hindsight API server in Kubernetes or Docker environments
  • Understanding how to use document_id for conversation evolution and upserts
  • Debugging memory retrieval issues or optimizing recall performance
Who it's for
  • AI agent developers integrating biomimetic memory systems
  • Backend engineers deploying Hindsight infrastructure
  • AI/ML engineers optimizing memory retrieval and reasoning
  • Teams building multi-user or multi-agent applications with persistent memory

hindsight-docs FAQ

Where should I start if I'm new to Hindsight?

Read references/best-practices.md first. It covers practical rules for missions, tags, content format, and anti-patterns—the fastest way to integrate correctly.

How do I find documentation on a specific topic?

Use the Glob tool to find files by pattern (e.g., references/**/*python*.md), the Grep tool to search content (e.g., pattern: 'disposition'), or the Read tool to access full files directly.

What are the main operations in Hindsight?

The four core operations are: Retain (store memories with auto-extracted facts/entities/relationships), Recall (retrieve memories using 4 parallel strategies), Reflect (disposition-aware reasoning), and Memory Banks (isolated stores per user/agent).

How do I handle multi-user or conversation evolution?

Use document_id to group messages in a conversation. Sending the same document_id performs an upsert, allowing conversations to evolve. Multi-bank queries require client-side orchestration.

What deployment options are available?

Hindsight API can be deployed via Docker, Kubernetes (with Helm), or pip installation. Configuration uses HINDSIGHT_API_* environment variables, and database migrations run 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
  • Find cookbook examples and recipes

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/ # LiteLLM, AI SDK, OpenClaw, MCP, skills
└── cookbook/
    ├── recipes/      # Usage patterns and examples
    └── applications/ # Full application demos

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

# Cookbook examples
references/cookbook/recipes/*.md
references/cookbook/applications/*.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/cookbook/
pattern: "def |async def "    # Find Python examples

3. Read Full Documentation (use Read tool)

references/developer/api/retain.md
references/sdks/python.md
references/cookbook/recipes/per-user-memory.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/. Run ./scripts/generate-docs-skill.sh to update.