vectorize-io/hindsight

Hindsight is a temporal-semantic memory system for AI agents that provides persistent long-term memory through retain, recall, and reflect operations. It offers a self-hostable API with Kubernetes deployment support, pluggable storage backends, and a modular engine for entity resolution and consolidation. The system integrates with a wide range of coding agents, frameworks, and workflows via official SDKs and plugins, enabling agents to maintain context across sessions.

Introduces the \hindsight\_claude\_agent\_sdk\ package, enabling Claude agents to maintain persistent memory through two approaches: explicit MCP tools (\hindsight\_retain\, \hindsight\_recall\, \hindsight\_reflect\) for on-demand memory operations, and automatic memory hooks that inject relevant memories into prompts and store agent results without explicit tool calls. The integration supports configuration via global settings or direct arguments, including API URL, key, budget levels, and tag-based filtering.

_hindsight-integrations/claude-agent-sdk/hindsight\_claude\_agent\sdk · high confidence

Users can now integrate Hindsight with the Continue.dev VS Code extension via a new HTTP context provider. This change adds the core logic in \hindsight\_continue/provider.py\ to translate Continue's request format (query, full input, options) into Hindsight memory recalls, supporting configuration overrides for bank ID, budget, and token limits, and returning formatted context items to the editor.

hindsight-continue · high confidence

This change introduces the Hindsight integration for Google's Gemini Spark by providing the necessary configuration scaffolding. It adds example manifests for both the Antigravity 2.0 agent (\manifest.example.yaml\) and the desktop/IDE MCP client (\mcp\_config.example.json\), along with a README detailing the architecture and setup steps for connecting Spark to Hindsight Cloud or a self-hosted instance. The entry also includes a test suite to validate that these configuration files parse correctly and contain the expected structure, such as HTTPS endpoints and authentication headers.

hindsight-integrations/gemini-spark · high confidence

Users can now connect GitHub Copilot CLI to Hindsight to automatically recall relevant past context and retain conversation history. This integration adds a new set of hook scripts that parse Copilot CLI's native JSONL transcript format, manage a local Hindsight embed daemon for offline memory storage, and support configurable bank IDs, recall queries, and LLM providers for fact extraction.

_hindsight-integrations/copilot-cli/hindsight\_copilot\cli/hooks/scripts · high confidence

Introduces a new integration that provides Haystack-compatible Tool instances backed by Hindsight's retain, recall, and reflect APIs. The implementation includes a HindsightMemoryWrapper with optional auto-recall and auto-retain capabilities, handling async client calls via a persistent background event loop to ensure compatibility with Haystack's synchronous tool requirements.

hindsight-haystack · high confidence

This change introduces the \hindsight\_haystack\ package, providing Haystack-compatible \Tool\ instances backed by Hindsight's retain, recall, and reflect APIs. Users can now integrate Hindsight memory capabilities into Haystack agents by using \create\_hindsight\_tools()\, which resolves the Hindsight client via explicit arguments, global configuration, or environment variables (e.g., \HINDSIGHT\_API\_KEY\). The package includes configuration management (\configure\, \get\_config\), error handling (\HindsightError\), and typed support (\py.typed\), enabling seamless memory augmentation for Haystack-based AI agents.

_hindsight-composio, hindsight-integrations/haystack/hindsight\haystack · high confidence

A new credential type named 'Hindsight API' has been added to the n8n integrations, allowing users to connect to the Hindsight memory service. This credential supports configuration of a custom API URL (defaulting to the Hindsight Cloud endpoint) and an optional API key for authentication. It automatically attaches a 'Bearer' token header when a key is provided and sets a specific User-Agent header ('hindsight-n8n') for all requests. Credential testing is performed against the /health endpoint to verify connectivity for both cloud and self-hosted instances.

hindsight-integrations/n8n/credentials · high confidence

Users can now install the Hindsight Dify plugin to add persistent long-term memory to their Dify workflows. The plugin provides three tools: Retain (to store content and tags in a memory bank), Recall (to search a bank for relevant memories), and Reflect (to get an LLM-synthesized answer over a bank). It supports both Hindsight Cloud and self-hosted instances, with credential validation via the Hindsight health endpoint.

hindsight-integrations/dify · high confidence

Introduces a new \hindsight-zcode\ package that provides long-term memory for ZCode (Z.ai's GLM desktop coding agent) via ZCode's native process hooks, eliminating the need for an MCP server. The integration installs hook scripts that automatically recall relevant context before each user prompt and retain conversation turns after each session, storing them in a Hindsight memory bank. It includes a CLI for installation and uninstallation, supports both Hindsight Cloud and local daemons, and offers configuration options for dynamic bank IDs, recall budgets, and retention frequency.

hindsight-integrations/zcode · high confidence

The \hindsight-integrations/eliza\ package introduces a plugin that gives elizaOS agents long-term memory backed by Hindsight. It registers a \HINDSIGHT\_MEMORY\ provider that recalls relevant memories and injects them into the prompt before each model call, and a \HINDSIGHT\_RETAIN\ evaluator that persists conversation messages to Hindsight after each turn. Both are enabled by default, layer on top of elizaOS's existing memory, and fail safe so a Hindsight outage never blocks the agent from responding. Users can configure memory banks (defaulting to the message \entityId\), control recall budget and types, and choose whether to retain the agent's own replies. The integration requires \@elizaos/core\ ^1.7.2 and \@vectorize-io/hindsight-client\.

hindsight-integrations/eliza, hindsight-integrations/omo · high confidence

Users can now integrate Hindsight memory capabilities directly into n8n workflows via a new Hindsight node. This node supports three operations: Retain (storing content in a memory bank), Recall (searching for relevant memories using natural language queries), and Reflect (generating LLM-synthesized answers based on stored memories). The implementation uses n8n's built-in HTTP authentication helpers, ensuring zero runtime dependencies for compatibility with n8n Cloud.

hindsight-integrations/n8n/nodes · high confidence

Introduces the Meta Muse integration, providing a preflight check module that validates an MCP endpoint's OAuth configuration and tool availability before connection. This ensures users can verify their self-hosted or proxied Hindsight deployments are correctly configured for Muse's custom-connector flow, including OAuth resource metadata discovery, dynamic client registration, and MCP tool listing.

hindsight-meta-muse · high confidence

Users can now deploy the Hindsight API behind an Nginx reverse proxy to serve the API under a custom base path (e.g., /hindsight). This change introduces a new docker-compose setup in the nginx directory that proxies API traffic while leaving the Control Plane accessible directly on port 9999. The configuration supports both a quick-start mode using the published image (API only via proxy) and a full-stack mode requiring a custom build to serve the Control Plane UI under the same subpath.

docker/docker-compose/nginx · high confidence

Introduces the Hindsight-Pipecat integration, providing a \HindsightMemoryService\ frame processor that adds persistent long-term memory to voice AI pipelines. Users can now slot this service between the user context aggregator and the LLM to automatically recall relevant memories before each turn and retain conversation content after, with configuration options for API URLs, keys, and recall budgets. The release includes example pipelines for both voice (using Daily, Deepgram, OpenAI, and Cartesia) and interactive text chat to demonstrate the memory recall and retain behavior.

_hindsight-integrations/pipecat/hindsight\pipecat · high confidence

A new extension, StaticKeysTenantExtension, is available to enable multi-user mode where API keys and user schemas are configured via environment variables. This allows operators to define users and their keys using HINDSIGHT\_API\_TENANT\_USERS, providing per-user PostgreSQL schema isolation with lazy provisioning. The extension supports multiple keys per user, uses constant-time comparison for security, and works for both HTTP and MCP authentication.

hindsight-ext-static-keys-tenant · high confidence

Introduces the \HindsightVapiWebhook\ integration, enabling persistent long-term memory for Vapi voice AI calls. The integration handles two key events: it recalls relevant caller history at call start (via the \assistant-request\ webhook) by injecting memories into the assistant's system prompt, and it retains full call transcripts after the call ends (via the \end-of-call-report\ webhook) for future recall. It supports both inbound calls (automatic recall by phone number) and outbound calls (manual override construction), and is framework-agnostic, working with FastAPI, Flask, or aiohttp.

hindsight-integrations/vapi · high confidence

A new benchmark suite in \hindsight-dev/benchmarks/document\_evolution\ evaluates whether living documents survive repeated LLM edits without structural degradation. The suite measures markdown-specific damage—such as collapsed tables, lost code fences, and flattened lists—using deterministic metrics, and assesses content quality via an LLM judge. It includes a CLI to run builds against a server and compare results, along with a baseline report demonstrating that the branch fixes the table-welding issue reported in \#3361.

_hindsight-dev/benchmarks/document\evolution · high confidence

A new benchmark located at \hindsight-dev/benchmarks/multimodal\_retain\ evaluates whether information contained in inline images (screenshots, diagrams) is successfully retained in memory. The benchmark runs two arms—multimodal (with images) and text-only (prose without images)—against a vision-capable LLM, measuring both fact coverage (whether image-specific details reached the bank) and answer correctness. It includes a CLI for running the benchmark and generating reports, a deterministic corpus of hand-written articles with generated images, and an LLM-based judge to verify results.

_hindsight-dev/benchmarks/multimodal\retain · high confidence

A new benchmark suite has been added to measure consolidation throughput and identify bottlenecks within the consolidation pipeline. This tool allows users to ingest test memories and run consolidation jobs while tracking time spent in key components such as recall, LLM processing, embedding generation, and database writes. The included documentation outlines configuration options, baseline performance metrics, and implemented optimizations like batched database queries and reduced recall token budgets.

hindsight-dev/benchmarks/consolidation · high confidence

A new benchmark has been added to measure the quality of the consolidation pipeline by quantifying duplicate observations. It ingests documents into a fresh bank, runs consolidation, and uses an observation-dedup tool to score exact and near-duplicate rates. The benchmark includes a sample dataset (herb\_garden.txt) designed to stress deduplication behavior through repeated facts across conversation turns.

hindsight-dev/benchmarks/obs · high confidence

A new pre-commit hook has been added to the repository. When a commit is made, this hook automatically discovers and executes all executable shell scripts located in the \scripts/hooks/\ directory, providing a centralized mechanism to run validation or formatting tasks before code is committed.

.githooks · high confidence

New scripts in the docs build process enforce consistency and accuracy across the documentation site. The \check-code-parity\ script ensures all MDX code examples include Python, Node.js, CLI, and Go variants. The \check-integrations\ script validates the integrations gallery against actual doc pages and changelogs, while \check-integration-seo\ ensures every integration page has required SEO metadata. The \check-featured-posts\ script validates pinned blog posts, and \check-templates\ validates bank template manifests against their JSON schema. Additionally, \check-mock-bank\ validates the synthetic memory bank used in the overview hero figure. Two new generation scripts (\sync-coding-agents-doc\ and \sync-hermes-doc\) automatically generate integration documentation pages from their respective README files, eliminating manual sync efforts and ensuring the docs stay current with the source of truth.

hindsight-docs/scripts · high confidence

The Claude Code integration plugin now persists session state to files to survive ephemeral hook processes, using conditional fcntl imports for Windows compatibility and flock-based locking to prevent race conditions during turn counting and retention planning. Additionally, a new documentation skill script converts Giotto-based animated SVG figures into step-by-step text narrations so that agents can understand diagram content without rendering capabilities.

python · high confidence

The Cursor CLI integration now supports an auto-managed local daemon mode, allowing users to run the Hindsight embed service locally without configuring an external API URL. This change introduces a new LLM provider detection system that automatically identifies providers (such as OpenAI, Anthropic, or Cursor) based on environment variables or plugin configuration, enabling the local daemon to perform fact extraction. The integration also adds robust configuration management, bank ID derivation logic, and state persistence to handle ephemeral hook processes, while adapting transcript parsing to support Cursor 3.x role-nested agent transcripts.

_hindsight-integrations/cursor-cli/hindsight\_cursor\cli/hooks/scripts · high confidence

The new hindsight-devin-desktop integration (v0.2.0) supports both Devin Desktop agents (Cascade and Devin Local) with a two-tier memory model: a global bank for cross-project preferences and a per-project bank derived from the git remote. For Devin Local, it adds deterministic memory hooks that auto-recall memory at session start and nudge the agent to retain facts before stopping, with visible status reporting. The integration also wires the Hindsight MCP server into both agents' configurations and writes always-on memory rules.

hindsight-integrations/devin-desktop · high confidence

The Hindsight integration for Devin Desktop has been expanded to configure both the legacy Cascade agent and the new Devin Local agent. For Cascade, the integration now writes MCP server entries to both documented configuration paths to ensure compatibility, adds a visibility banner hook to \\hooks.json\\ to display tool usage, and manages global and per-project memory rules. For Devin Local, it configures the MCP server with HTTP transport and auto-approval permissions, and installs always-on instructions via \\AGENTS.md\\ files. Both agents now operate in multi-bank mode, allowing the system to isolate memory to specific projects while maintaining a global bank for cross-project preferences.

hindsight-devin-desktop · high confidence

This release adds a hierarchical learning system for agents: Observations automatically consolidate raw facts into synthesized knowledge, Mental Models allow users to curate and store pre-computed responses for common queries, and Directives provide hard compliance rules that agents must follow during reflection. It also unifies previous entity summaries and opinions into the new Observation type.

hindsight-docs/blog · high confidence

The \hindsight-cli\ directory is introduced with the foundational structure for the Rust-based command-line interface. This includes a \.gitignore\ for Rust artifacts, a \build.sh\ script to compile binaries for macOS (Intel/ARM) and Linux (x86\_64/ARM64), and a \smoke-test.sh\ script to verify basic CLI functionality against a running API server. Additionally, \about.toml\ and \about.hbs\ are added to configure and generate third-party software license notices for the distributed binary, ensuring compliance with open-source licensing requirements.

hindsight-cli · high confidence

The Hindsight Cline integration now includes a complete library of hooks that automatically recall relevant past memories during coding tasks and retain new context upon task completion. This change introduces a zero-dependency HTTP client, a configuration system supporting environment variables and settings files, and logic to manage bank IDs and missions. Users will see relevant historical conversation snippets injected into their Cline prompts and their current work automatically saved to their Hindsight memory bank, with state persisted locally to handle Cline's ephemeral hook environment.

_hindsight-cline, hindsight-integrations/cline/hindsight\cline/hooks · high confidence

The Hindsight documentation site is now available, built on Docusaurus with a new sidebar structure, versioned documentation support (versions 0.7 through 1.0), and an integrations hub. The site includes a dedicated API reference, blog section, and a plugin system for integration changelogs. It also features a custom navbar with icons and GitHub star count, and supports multilingual content. The site is configured to use Rspack and SWC for faster builds, and includes a memory defense section.

hindsight-docs · high confidence

The Hindsight Helm chart is now available, providing a complete Kubernetes deployment for the Hindsight application. The chart introduces a modular architecture that separates the API, control plane, and worker services into distinct Deployments or StatefulSets, allowing for independent scaling and configuration. It supports optional TEI (Text Embeddings Inference) components for reranking and embeddings, which can be enabled as separate deployments. Key features include configurable autoscaling via HorizontalPodAutoscalers, PodDisruptionBudgets for high availability, and support for both standard Ingress and Kubernetes Gateway API HTTPRoutes. The chart also handles database connectivity via an optional embedded PostgreSQL StatefulSet or external connections, manages secrets (including support for existing Kubernetes secrets), and exposes metrics through Prometheus ServiceMonitors. Post-installation, users can access the control plane via port-forwarding as indicated in the NOTES.txt.

helm/hindsight/templates · high confidence

The repository is initialized with essential configuration and documentation files, including a Docker ignore list, environment variable examples, and linting/formatter settings for Python (Ruff) and TypeScript (Prettier). Standard open-source governance documents such as the MIT License, Code of Conduct, Contributing guide, and Security policy are added, alongside a Deno lockfile. This change also removes legacy proof-of-concept artifacts, specifically the old database schema and graph visualization HTML, replacing them with a modern, structured project layout.

(repo-wide) · high confidence

Added a new \hindsight-crewai\ integration that provides persistent memory for CrewAI agent crews. This includes a \HindsightStorage\ backend implementing CrewAI's \Storage\ interface for automatic memory flow, support for per-agent isolated memory banks, and a \HindsightReflectTool\ for disposition-aware memory synthesis. The release also includes a manual integration test (\test\_manual.py\) to verify save, search, and crew execution workflows against a local Hindsight API.

hindsight-integrations/crewai · high confidence

This change introduces the \@vectorize-io/n8n-nodes-hindsight\ package, enabling n8n workflows to integrate with Hindsight for persistent long-term memory. Users can now install the community node to perform three key operations: Retain (storing facts and context), Recall (searching memory banks via natural language), and Reflect (generating LLM-synthesized answers from accumulated knowledge). The package includes the necessary TypeScript configuration, entry points, and credential definitions to support both Hindsight Cloud and self-hosted deployments.

hindsight-integrations/n8n · high confidence

This change introduces the new \hindsight\_litellm\ package, enabling LiteLLM to integrate with the Hindsight memory system. It provides a synchronous API wrapper that manages a dedicated event loop per thread to safely bridge sync calls to the underlying async Hindsight client, avoiding deprecation warnings and session reuse issues. The integration includes a comprehensive configuration module (\config.py\) allowing users to set connection details (API URL, key), default memory settings (budget, injection mode, tags), and per-call overrides for features like memory recall, reflection, and tagging. A \py.typed\ marker is also added to support static type checking.

_hindsight-integrations/litellm/hindsight\litellm · high confidence

The Go client SDK for Hindsight is now available, generated from the OpenAPI specification. This library provides typed Go structs and methods for all Hindsight API endpoints, including banks, documents, memories, mental models, and operations. It includes support for server URL configuration, proxy settings, and automatic handling of API responses and errors. The SDK is versioned at 1.0.0 and requires Go modules for dependencies like \testify\ and \context\.

hindsight-clients/go · high confidence

This change introduces the Hindsight Control Plane as a standalone Next.js application, providing the web interface and CLI for managing knowledge banks, mental models, and documents. It includes the core UI components, internationalization (i18n) support, and a standalone server entry point (\bin/cli.js\) that handles binding, port configuration, and API URL forwarding. The release also adds static assets such as harness logos and configuration files for linting, formatting, and Docker deployment.

hindsight-control-plane · high confidence

This change introduces the first version of the Helm chart for deploying Hindsight, a temporal-semantic-entity memory system for AI agents. The chart provides a complete deployment configuration for the API, control plane, and worker components, including support for PostgreSQL (bundled or external), Ingress, and Gateway API routing. It also includes configurable liveness and readiness probes, pod disruption budgets, affinity settings, and the ability to inject extra containers and init containers for sidecars.

helm/hindsight · high confidence

The Python SDK for the Hindsight HTTP API is now available, providing a generated client library (version 0.0.7) based on OpenAPI specification 1.0.0. This package exposes typed models and API wrappers for all server endpoints, including audit logs, bank management, document transfer, mental models, memory operations, and webhooks. It supports both synchronous and asynchronous execution via \aiohttp\, includes built-in retry logic, and is fully type-hinted to support static analysis.

_hindsight-clients/python/hindsight\_client\api · high confidence

This change introduces the initial version of the Hindsight Python client, generated via OpenAPI Generator. The package, named \hindsight\_client\_api\ (version 0.0.7), is built on the \asyncio\ library and includes only source code, with tests and documentation generation disabled to allow for custom implementations. The release includes configuration files for the generator and a basic README.

hindsight-clients/python · high confidence

The new \@vectorize-io/hindsight-all\ npm package provides a Node.js API for managing the lifecycle of the local Hindsight daemon. It allows applications to start, stop, and check the health of the embedded \hindsight-embed\ process programmatically, handling profile configuration and environment variable forwarding. The package requires Node.js \>= 22 and \uv\ on the PATH, and is designed to compose with \@vectorize-io/hindsight-client\ for API interactions.

hindsight-all-npm · high confidence

The \hindsight-integrations/chat\ package is now available, providing a \withHindsightChat\ wrapper for the Vercel Chat SDK that enables bots to maintain persistent, per-user memory across platforms like Slack, Discord, and Teams. The integration automatically recalls relevant memories before processing a message and can optionally auto-retain inbound messages and responses, passing a context object to the handler that includes formatted system prompts, entity observations, and manual recall/retain methods. It supports configuration for memory banks, recall budgets, and fact-type filtering, with graceful error handling that ensures bot functionality continues even if memory operations fail.

hindsight-integrations/chat · high confidence

A new Cloudflare Worker integration has been added to enable cloud-based MCP clients (such as Claude.ai, Claude Code, and Codex) to connect to a self-hosted Hindsight instance. This proxy handles the OAuth 2.1 authorization flow, requiring a one-time password entry to authenticate the user, and securely proxies MCP traffic to the origin through a Cloudflare Tunnel. It enforces strict security measures, including PKCE (S256 only), CORS restriction to allowlisted origins, and header sanitization to prevent information leakage.

hindsight-integrations/cloudflare-oauth-proxy · high confidence

Adds the \hindsight\_crewai\ package (v0.1.0), providing a \HindsightStorage\ backend that implements CrewAI's \Storage\ interface to persist agent memories to Hindsight, and a \HindsightReflectTool\ that allows agents to synthesize contextual answers from that memory. The integration includes global configuration via \configure()\ (supporting API URL, key, budget, and tag settings), per-agent bank isolation, and a compatibility layer (\\_compat.py\) that uses a dedicated thread pool with persistent event loops to safely handle the Hindsight client's async operations within CrewAI's execution environment.

(repo-wide) · high confidence

The API module has been restructured into a new slim package that unifies HTTP REST and Model Context Protocol (MCP) servers. This release introduces admission control to bound request wait times, returning 503 with a Retry-After header when capacity is exceeded, and adds a pure-ASGI middleware to detect client disconnects on long-running operations (recall, reflect, retain, graph) so that abandoned work is cancelled immediately. The HTTP layer is also optimized by replacing Starlette's BaseHTTPMiddleware with pure-ASGI handlers to reduce latency and CPU usage, and the MCP server is now integrated as a middleware with configurable mounting.

_hindsight-api-slim/hindsight\api/api · high confidence

The Hindsight CLI is now available, providing a command-line interface to manage banks, memories, documents, entities, mental models, and the knowledge base. It supports named connection profiles (via \-p\ or \HINDSIGHT\_PROFILE\) to switch between different API configurations, with environment variables taking precedence. The CLI also features structured error handling that surfaces the server's response body and specific HTTP status details (e.g., 400 Bad Request, 404 Not Found) to help users diagnose issues, and it intelligently suppresses ANSI color codes when output is piped or sent to a non-TTY terminal.

hindsight-cli/src · high confidence

This change adds the \hindsight-coding-agents\ package, providing long-term project memory for coding agents. It installs hooks and plugins for a wide range of harnesses (including Claude Code, Codex CLI, DeepAgents Dcode, opencode, Cursor CLI, GitHub Copilot CLI, Grok Build, Qwen Code, Kimi Code, Factory Droid, ZCode, TraeCode, Antigravity CLI, Devin CLI, Cline CLI, pi, Prime Agent, DeepSeek Harness, WorkBuddy, and CodeBuddy) to automatically ingest git history and conversation transcripts into a Hindsight memory bank. The package includes a companion skill for agents to interact with the memory, an installer for wiring agents, and a suite of E2E Dockerfiles to test each harness.

hindsight-integrations/coding-agents · high confidence

Adds three new Flowise tool nodes—Hindsight Retain, Hindsight Recall, and Hindsight Reflect—that enable long-term memory capabilities in Flowise chatflows and agents. These nodes wrap the Hindsight API via the @vectorize-io/hindsight-client, allowing users to store content, search memory banks, and synthesize answers over past context. The integration includes a shared HindsightApi credential for configuring the API URL and key, and each node identifies itself to the API with a dedicated User-Agent header.

hindsight-integrations/flowise · high confidence

Adds a new integration package that provides \retain\, \recall\, and \reflect\ tools for the Vercel AI SDK, enabling AI agents to store, retrieve, and reason over long-term memory. The package includes TypeScript definitions, a build configuration, and a compatibility shim to support running tests in Deno environments.

hindsight-integrations/ai-sdk · high confidence

Adds a new TypeScript-based Hindsight plugin for Paperclip that provides persistent long-term memory for agents. The plugin automatically recalls relevant context before each agent run and retains issue comments after they are created, while also exposing \hindsight\_recall\ and \hindsight\_retain\ tools for mid-run memory access. Memory isolation is configurable via \bankGranularity\ (supporting company, agent, and user levels) and agent enablement can be restricted using \enabledAgentIds\.

hindsight-integrations/paperclip · high confidence

This release adds the Hindsight plugin for Obsidian, enabling one-way vault sync to a Hindsight memory bank and a side-panel chat that answers questions grounded in your notes with source citations. The plugin supports incremental sync (upserts/deletes based on content hashes), automatic scoping via vault/folder/date tags, and configurable observation scopes for content consolidation. It includes a headless CLI (\hindsight-obsidian-sync\) for server-side ingestion, a dedicated distribution repository for community store installation, and version bumps up to 0.3.0.

hindsight-integrations/obsidian · high confidence

The worker package is now available as a standalone component for distributed task execution. It provides a CLI entry point (\hindsight-worker\) that polls PostgreSQL for pending tasks and executes them using \FOR UPDATE SKIP LOCKED\ for safe concurrent claiming. The worker includes a minimal HTTP server exposing \/health/live\ (a DB-free liveness probe to prevent restarts during database slowness), \/health/ready\ (readiness check), and \/metrics\ (Prometheus metrics rendered off the event loop). It implements backpressure handling by deferring writes when the store is shedding (e.g., due to indexing backlog) or when append conflicts occur, rather than failing them immediately. The worker also enforces wall-clock ceilings on tasks like retains and consolidations to prevent wedged operations from holding slots indefinitely, and supports graceful shutdown with signal handling.

_hindsight-api-slim/hindsight\api/worker · high confidence

The \hindsight-all/hindsight\ package now provides \HindsightEmbedded\ and \Server\ classes, enabling users to run the Hindsight semantic memory system locally without external dependencies. \HindsightEmbedded\ manages the daemon lifecycle automatically, supports profile-based configuration inheritance (fixing previous credential overwrites), and includes a liveness check to recover from daemon crashes. \Server\ allows running the HTTP API in a background thread with embedded PostgreSQL. The package also exposes organized API namespaces (Banks, MentalModels, Directives, Memories) and includes a \py.typed\ marker for type checking.

hindsight-all/hindsight · high confidence

Adds a new integration package (\hindsight-agentcore\) that enables persistent memory for agents running on the AWS Bedrock AgentCore Runtime. The library provides a \HindsightRuntimeAdapter\ and a \TurnContext\ model to automatically recall relevant memories before each agent turn and retain outputs afterwards, ensuring user context survives Runtime session reprovisioning. It includes a default bank resolver that maps tenant, user, and agent identities to stable memory banks, preventing cross-user leakage and ignoring volatile session IDs.

hindsight-agentcore, hindsight-integrations/agentcore/examples · high confidence

Adds the \hindsight\_google\_adk\ package, enabling Google ADK agents to persist and retrieve long-term memory via Hindsight. Users can now attach a \HindsightMemoryService\ to an ADK \Runner\ for automatic session-based memory retention and recall, or use the \create\_hindsight\_tools\ factory to expose explicit \hindsight\_retain\, \hindsight\_recall\, and \hindsight\_reflect\ tools to an \LlmAgent\. The integration supports configurable bank scoping, tag-based filtering, and connection settings via a global \configure\ function or per-instance arguments.

_hindsight-integrations/google-adk/hindsight\_google\adk · high confidence

This release adds the \hindsight-copilot-cli\ integration, which installs Python-based hooks into GitHub Copilot CLI to provide persistent, long-term memory across sessions. The integration automatically recalls relevant project context at \sessionStart\ and \subagentStart\ (injecting it as \additionalContext\) and retains conversation transcripts to Hindsight at \agentStop\ (every N turns) and \sessionEnd\. It supports both user-level and repository-level hook registration, dynamic memory banks scoped by agent and project, and configurable recall budgets and retention frequencies.

hindsight-integrations/copilot-cli · high confidence

Adds a new Python-based integration for the OpenAI Codex CLI that enables automatic memory recall and retention. The change introduces a suite of scripts (recall.py, retain.py, session\_start.py) and library modules (bank, client, config, content, daemon, llm, state, upgrade\_notice) that handle hook execution, configuration loading, and communication with the Hindsight API. Key capabilities include dynamic bank ID derivation based on agent, project, session, and user context; structured tool call retention from Codex rollout files; configurable recall timeouts and score floors; and a deprecation notice guiding users toward the Coding Agents plugin.

hindsight-integrations/codex/scripts · high confidence

Adds the \hindsight-openhands\ package, which provides a CLI (\hindsight-openhands\) to wire the Hindsight MCP server into OpenHands' \config.toml\ and inject a recall/retain rule into \AGENTS.md\. This enables OpenHands agents to automatically use \recall\, \retain\, and \reflect\ tools for long-term memory, supporting both native Streamable-HTTP MCP connections and Docker-based setups.

hindsight-integrations/openhands, hindsight-openhands · high confidence

Adds a new Hindsight memory plugin for Cursor that automatically recalls relevant past coding sessions and retains new context. The plugin manages its own local daemon (hindsight-embed) for fact extraction, supports dynamic bank IDs based on session context, and handles memory retention and recall via a REST API. It includes configuration for API endpoints, LLM providers, and memory settings, with fallbacks for local and hosted backends.

hindsight-integrations/cursor/scripts · high confidence

This change adds the \@vectorize-io/opencode-hindsight\ plugin, enabling the OpenCode AI coding agent to retain and recall long-term memory across sessions. The plugin provides custom tools (\hindsight\_retain\, \hindsight\_recall\, \hindsight\_reflect\) and automatic retention on session idle. It defaults to Hindsight Cloud but supports self-hosted instances via configuration. Key features include dynamic bank ID derivation (supporting git worktree sharing via \gitProject\ granularity), configurable recall budgets and tag filtering, and memory injection during context compaction to survive window trimming.

hindsight-integrations/opencode · high confidence

Adds a new Hindsight integration plugin for Claude Code that enables automatic memory recall and retention. The plugin includes a Python library for managing bank IDs, configuration, and content processing, along with scripts for auto-recall and auto-retain hooks. It also features an MCP server exposing knowledge tools for managing memory pages and a daemon lifecycle manager for local Hindsight server management.

hindsight-integrations/claude-code/scripts · high confidence

Adds a new \hindsight\litellm\ package that integrates Hindsight memory capabilities with LiteLLM, allowing automatic memory injection before LLM calls and conversation storage afterward. The integration supports 100+ LLM providers via LiteLLM, offers native client wrappers for OpenAI and Anthropic, and provides strict error handling for memory operations. Users can configure memory banks, set per-call defaults, and override settings via \hindsight\\*\ kwargs, with support for multi-user scenarios through separate bank IDs and session grouping.

hindsight-litellm · high confidence

Adds the \hindsight\_llamaindex\ package, providing two integration patterns for LlamaIndex agents: \HindsightToolSpec\ for agent-driven memory operations (retain, recall, reflect) and \HindsightMemory\ for automatic long-term memory storage and retrieval. The package includes global configuration via \configure()\, client resolution that defaults to the cloud API and \HINDSIGHT\_API\_KEY\ environment variable, and a PEP 561 \py.typed\ marker for type checking.

_hindsight-integrations/llamaindex/hindsight\llamaindex · high confidence

Adds the \hindsight\_strands\ package, providing persistent memory tools for Strands agents. Users can now equip agents with long-term memory capabilities via \retain\, \recall\, and \reflect\ tools backed by the Hindsight API. The integration includes configuration management for API credentials and connection settings, proper resource cleanup for internal clients, and a \py.typed\ marker for type-checking support.

_hindsight-integrations/strands/hindsight\strands · high confidence

Adds the Oh-My-OpenAgent (OMO) integration, enabling the system to automatically recall relevant past memories and retain conversation context. This change introduces a Python-based library that manages bank IDs (supporting dynamic granularity and Git worktree resolution), communicates with the Hindsight API for recall and retention operations, and handles local state persistence for session tracking and mission configuration.

hindsight-integrations/omo/scripts · high confidence

Adds the \hindsight\_openai\_agents\ package, providing \FunctionTool\ instances that enable OpenAI Agents SDK agents to store, search, and synthesize information using Hindsight's long-term memory APIs. Users can now pass these tools directly to an \Agent\ to retain facts, recall relevant context, and reflect on stored memories, with configuration options for API endpoints, authentication, and memory budgeting.

_hindsight-integrations/openai-agents/hindsight\_openai\agents · high confidence

A new SQL dialect abstraction layer has been added to the engine, providing a unified interface for database-specific SQL syntax across PostgreSQL and Oracle 23ai. This change isolates platform-specific details—such as parameter placeholders, JSON operators, vector distance functions, and full-text search scoring—behind a common API, enabling the application to support multiple database backends without embedding raw SQL fragments in business logic.

_hindsight-api-slim/hindsight\api/engine/sql · high confidence

The \hindsight-integrations/superagent\ package adds a \SafeHindsight\ wrapper that applies Superagent Guard and Redact checks to Hindsight memory operations. Content is now guarded against prompt injection and redacted for PII before storage, and queries are guarded before recall or reflect. The middleware supports configurable safety per operation (retain, recall, reflect), batch ingestion with concurrency limits, and global configuration via environment variables or a \configure()\ call.

hindsight-integrations/superagent · high confidence

This change adds a new, auto-generated Rust client library for the Hindsight API, built using the progenitor code generator. The library provides fully typed, async-first methods for all API endpoints (agents, memories, documents, operations) and includes a build script that converts the OpenAPI 3.1 spec to 3.0, filters unsupported multipart endpoints, and resolves schema conflicts (such as bodyless 404 errors and colliding inline enum titles) to ensure successful code generation. It also introduces a \User-Agent\ header strategy via \client\_with\_user\_agent\ and \default\_client\ to help integrations identify themselves and avoid being blocked by reverse proxies. To assist with adoption, the package includes an integration guide detailing how to bridge the async client with existing blocking CLI code or migrate to a fully async architecture.

hindsight-clients/rust · high confidence

A new \hindsight-system-evals\ package has been added to provide blackbox quality evaluations against a real \hindsight-api\ process and a real model, replacing the previous in-repo LoComo/LongMemEval runners. Unlike the deterministic \hindsight-system-tests\ which use stubs, this package requires real provider credentials and is not run on PRs. It includes a comprehensive suite of tests: \test\_01\ for knowledge-page convergence (ensuring pages don't lose facts during delta refreshes), \test\_02\ for reflect answer grounding, \test\_03\ for retain language fidelity, \test\_04\ for retain fact extraction accuracy (preventing fabricated metadata), \test\_05\ for measuring refresh token costs, \test\_06\ for page-layer retrieval, \test\_07\ for source priority, \test\_09\ for coding-agent decision model performance, and \test\_11\ for page update handling. The package also includes a deterministic metric test for coding agents (\test\_00\) and a README detailing the evaluation methodology and fixtures.

hindsight-system-evals · high confidence

A new Docusaurus plugin has been added to fetch the live star count for the 'vectorize-io/hindsight' repository at build time, displaying this number in the navbar and homepage hero to provide social proof. The implementation includes a 5-second timeout to prevent build hangs and uses a hardcoded fallback value of 40,000 stars if the API request fails, ensuring the build remains stable even in offline or rate-limited CI environments.

hindsight-docs/plugins/github-stars · high confidence

The transfer module now allows exporting and importing bank documents as ZIP archives without re-running the LLM. Exports capture extracted facts, entities, causal relations, and chunks (excluding embeddings and database IDs), while imports replay the deterministic retain pipeline on the target bank to re-embed and re-resolve entities. The implementation supports streaming exports to avoid memory spikes, handles bank configuration and mental models, and remaps IDs to ensure compatibility across different banks or instances.

_hindsight-api-slim/hindsight\api/engine/transfer · high confidence

The API now supports a pluggable extension architecture, allowing operators to customize behavior without modifying core code. This includes built-in extensions for tenant authentication (single-tenant or API-key based), regex-based memory defense to redact secrets and PII from retained content, and hooks for LLM request routing and credential selection. The system also provides interfaces for HTTP endpoints, MCP tools, and operation validation, with extensions loaded via environment variables and isolated from core dependencies.

_hindsight-api-slim/hindsight\api/extensions · high confidence

The Python client now provides a clean, high-level \\Hindsight\\ wrapper that simplifies common operations like \\retain\\, \\recall\\, and \\reflect\\ while exposing low-level API access for advanced use cases. A key usability improvement is the addition of Pythonic dunder methods to response objects: \\RecallResponse\\ is now iterable, indexable, and has a custom \\\_\repr\\_\\ for better REPL output, along with a \\to\_prompt\_string()\\ method to easily serialize results for LLM prompts. The SDK also includes a \\py.typed\\ marker file to enable static type checking for users.

_hindsight-clients/python/hindsight\client · high confidence

Adds a new \hindsight-aider\ wrapper that integrates the Hindsight long-term memory system with the Aider pair-programming CLI. The integration automatically recalls relevant project context before each Aider session by injecting it via a read-only file, and retains the session transcript afterwards so that knowledge persists across sessions. Memory is scoped per Git repository by default, allowing shared context across other Hindsight editor integrations. The package includes configuration via environment variables or a JSON file, and is supported by a comprehensive test suite covering configuration loading, bank resolution, CLI passthrough, and the recall/retain orchestration logic.

hindsight-integrations/aider · high confidence

Adds the \hindsight-api-slim\ package containing the new consolidation engine, which automatically creates and updates observations from memories. This engine runs as a background job after retain operations, using a decision model to triage facts and an LLM to handle complex updates, while enforcing strict deduplication, source language preservation, and transactional integrity for observation writes.

_hindsight-api-slim/hindsight\api/engine/consolidation · high confidence

The engine module is reorganized into the new hindsight-api-slim package, introducing a bank alias system that allows zero-downtime bank ID migrations by resolving alternate names to canonical IDs at the HTTP edge. It also adds a fire-and-forget audit logging system that tracks feature usage across HTTP, MCP, and system transports, with per-bank configuration overrides and background write draining to ensure data integrity during shutdown.

_hindsight-api-slim/hindsight\api/engine · high confidence

Adds the \hindsight-embed\ package, providing a local CLI for memory operations that automatically manages a background daemon (running on localhost:8888 with an embedded PostgreSQL database). The release includes a new control center web app for managing profiles, viewing logs, and controlling the daemon lifecycle, along with support for named configuration profiles and external API server connections.

_hindsight-embed/hindsight\embed · high confidence

A new localhost-only web application is bundled with hindsight-embed to manage LLM profile configurations and supervise the background daemon. Users can now start, stop, and restart the daemon and UI components, configure LLM providers (including Atlas Cloud and Meta Model API), and edit environment variables via a token-gated HTTP interface bound to 127.0.0.1. The control center runs as a separate process on port 7878 (configurable via HINDSIGHT\_EMBED\_CONTROL\_PORT), uses a persisted access token for CSRF defense, and provides a single-page interface for viewing profile status, health checks, and logs.

_hindsight-embed/hindsight\_embed/control\center · high confidence

The retain engine is restructured into a modular package under \\hindsight\_api/engine/retain\\, exposing distinct components for fact extraction, embedding processing, entity handling, link creation, and chunk/fact storage. This refactor introduces first-class support for multimodal content: documents can now include inline images and files (via base64-attached \\ImageContentBlock\\ and \\FileContentBlock\\) alongside text. These attachments are canonicalized into deterministic placeholders within the document body to preserve idempotency and chunking logic, while the actual bytes are persisted to the existing file storage backend and tracked in a new \\attachments\\ database table. The module also includes utilities for bank vector index management, embedding coalescing to batch concurrent requests, and entity label configuration with legacy migration support.

_hindsight-api-slim/hindsight\api/engine/retain · high confidence

The file parsing subsystem has been replaced with a new modular engine in \hindsight\_api/engine/parsers\. This change introduces a \FileParserRegistry\ that manages parser implementations (Iris, LlamaParse, and Markitdown) and provides automatic file-type detection. A key behavioral improvement is the \convert\_with\_fallback\ method, which attempts parsers in a specified order and automatically retries with the next parser if the current one fails or returns empty content, improving reliability for ambiguous file types. The Markitdown parser now supports optional OCR via OpenAI-compatible models and includes a fix for mis-detected UTF-8 files with ASCII prefixes. Additionally, startup performance is improved by deferring the import of the \markitdown\ and \openai\ libraries until they are actually needed.

_hindsight-api-slim/hindsight\api/engine/parsers · high confidence

Adds the \@vectorize-io/hindsight-client\ TypeScript SDK, providing a typed wrapper around the Hindsight API. The client exposes methods for retaining and recalling memories, reflecting on data, and managing banks, mental models, and documents. It includes built-in support for idempotent request retries with jittered backoff, configurable User-Agent headers for integration tracking, and a version-checking utility to enforce server compatibility. The package is built with tsup for both CommonJS and ESM outputs and generated from the OpenAPI specification.

hindsight-clients/typescript · high confidence

The engine now supports Oracle 23ai alongside PostgreSQL through a new \hindsight\_api.engine.db\ module. This layer provides a unified interface (\DatabaseBackend\, \DataAccessOps\) that decouples business logic from specific database drivers, allowing the system to run on either PostgreSQL or Oracle. The implementation includes dialect-specific optimizations, such as query rewriting for Oracle compatibility, and adds instrumentation to track database connection pool wait times for better health monitoring.

_hindsight-api-slim/hindsight\api/engine/db · high confidence

This change introduces the \hindsight\api.engine.reflect\ package, providing the core implementation for the Reflect agent. The module exposes a public API via \\\init\\_.py\ that includes the main \run\_reflect\_agent\ function, result models (\ReflectAgentResult\), and error types. It implements the agent's iterative reasoning loop (\agent.py\) which utilizes hierarchical retrieval (mental models, observations, and raw recall) and native tool calling. The package also includes logic for structured mental model updates via delta operations (\delta\_ops.py\), evidence-grounded observation models with computed trends (\observations.py\), prompt presentation and ID aliasing to manage context (\presentation.py\), system and user prompt construction (\prompts.py\), and handling of retracted grounding when cited facts no longer exist (\retractions.py\).

_hindsight-api-slim/hindsight\api/engine/reflect · high confidence

The search module is restructured into a modular pipeline that executes four parallel retrieval arms (semantic, BM25, graph, and temporal) and fuses their results. To prevent timeouts on the native Postgres BM25 backend, the new \bm25\_term\_selection\ module filters query tokens by document frequency, keeping only the most selective terms. A new \DecisionModelReranker\ allows recall to rank candidates by asking a decision model whether each memory helps answer the question. Users can now prioritize specific retrieval arms (semantic, BM25, graph, temporal) over others using the \HINDSIGHT\_API\_RECALL\_STRATEGY\_BOOSTS\ environment variable, which applies rank-space promotion before the reranker and additive bumps after. The module also introduces fuzzy tag matching to resolve typos in user-provided tags and configurable recency decay functions (linear, exponential, or none) to control how memory freshness influences ranking.

_hindsight-api-slim/hindsight\api/engine/search · high confidence

This release adds the Hindsight Memory plugin for Cursor, providing automatic long-term memory for your coding sessions. The plugin installs via \pip install hindsight-cursor\ and registers hooks to automatically recall relevant project context at the start of each session and retain conversation transcripts after tasks. It works around a Cursor 3.x bug by writing recalled memories to a workspace rules file, supports on-demand memory operations via MCP tools (recall, retain, reflect), and allows connecting to either Hindsight Cloud or a local self-hosted server.

hindsight-integrations/cursor · high confidence

The \hindsight\api.engine.providers\ package now uses PEP 562 \\\getattr\\_\ to load provider implementations on first access rather than at import time. This prevents heavy SDKs (such as \google-genai\ and \openai\) from slowing down startup when they are not used, and the package exposes the full set of available providers (including Anthropic, Claude Code, Codex, Cursor, Fireworks, Gemini, GitHub Copilot, LiteLLM, LlamaCpp, Mock, None, OpenAI Compatible, and OpenAI Responses) through a single import.

_hindsight-api-slim/hindsight\api/engine/providers · high confidence

This release introduces \@vectorize-io/hindsight-eve\, a memory provider for Vercel Eve agents that enables long-term memory without requiring the model to call tools. The integration automatically recalls relevant memories before each turn and retains the user message and assistant reply after the turn completes, with memory isolated per scope (e.g., per user or tenant). It includes a new first-class memory provider (\hindsightMemory\) for Eve's memory slots, deprecated legacy auto-memory hooks (\hindsightAutoRecall\, \hindsightRetainHook\), and a \reflect\ tool for on-demand long-term memory queries. Configuration is handled via environment variables (\HINDSIGHT\_API\_KEY\, \HINDSIGHT\_API\_URL\) or direct options, supporting both Hindsight Cloud and self-hosted instances.

hindsight-integrations/eve · high confidence

Added developer API reference pages for Bank Templates (declarative JSON manifests for creating and configuring memory banks), Documents (tracking and managing document sources for retained content), and core memory operations including listing, fetching, and curating (editing, invalidating, restoring) individual memory units. The documentation also covers the asynchronous operations system, detailing how background tasks like retain, consolidation, and mental model refreshes are managed, tracked, and cancelled via a shared queue and REST endpoints.

_hindsight-docs/versioned\docs/version-0.8/developer/api · high confidence

A new Templates Hub page has been added to the documentation site, allowing users to browse, search, and filter pre-built bank templates by category (such as chat, coding, business, and support). The page features a hero section with a search input and displays template cards that link to a modal for viewing the full JSON manifest, which can be copied for use with the bank import API.

hindsight-docs/src/pages/templates · high confidence

The CLI now includes new subcommands to inspect audit logs (list, get, stats) and view bank disposition traits, filter document listings by date (today, yesterday, or specific YYYY-MM-DD), and mirror a bank's knowledge base to a local folder via the \hindsight fs\ command (mount, sync, daemon management). These additions expand the CLI's capabilities for operational auditing, bank configuration visibility, and local knowledge-base access.

hindsight-cli/src/commands · high confidence

Users can now connect their Continue.dev coding assistant to Hindsight for persistent long-term memory. This integration provides a lightweight adapter server that implements Continue's HTTP context provider contract, allowing users to type \@hindsight\ in chat to recall relevant project context at query time. It also includes optional configuration for automatic recall and retention via Continue's MCP server and rules in agent mode. The package includes a CLI for running the adapter and example configurations for both Hindsight Cloud and self-hosted instances.

hindsight-integrations/continue · high confidence

The documentation site now features a dedicated Cookbook landing page (\/cookbook\) that organizes practical examples into two distinct sections: 'Recipes' for focused learning tasks (such as quickstarts, per-user memory, and tool learning) and 'Applications' for complete demo builds (including customer service copilots, insurance triage agents, and multi-platform chat bots). This new entry point uses a \CookbookGrid\ component to display these items with consistent metadata, providing users with a centralized hub to discover Hindsight integrations across various SDKs like \hindsight-client\, \hindsight-litellm\, and \@vectorize-io/hindsight-chat\.

hindsight-docs/src/pages/cookbook · high confidence

Users can now install the \hindsight-copilot\ package to connect VS Code's Copilot agent mode to Hindsight's long-term memory. The \hindsight-copilot init\ command automatically configures the Hindsight MCP server in \.vscode/mcp.json\ and writes a recall/retain rule to \.github/copilot-instructions.md\, enabling Copilot to use \recall\, \retain\, and \reflect\ tools to access project context and store durable facts across sessions.

hindsight-copilot, hindsight-integrations/github-copilot · high confidence

This change introduces the \hindsight-agentcore\ package, providing a durable memory layer for agents running on Amazon Bedrock AgentCore Runtime. Since AgentCore sessions are ephemeral, this integration enables agents to remember users, decisions, and patterns across multiple sessions. The package exposes a \HindsightRuntimeAdapter\ with \before\_turn\ and \after\_turn\ hooks to automatically retrieve relevant memories before execution and retain outputs afterward. It includes configuration utilities (\configure\, \get\_config\) for setting API credentials and tuning recall/retention policies, along with specific error types like \BankResolutionError\.

_hindsight-integrations/agentcore/hindsight\agentcore · high confidence

Users can now connect Hindsight to Zapier to automate workflows using long-term memory. The integration provides actions to store content (Retain), search memories (Recall), and get LLM-synthesized answers (Reflect). It also includes instant triggers via REST hooks to start Zaps when memory operations complete (Retain Completed, Consolidation Completed). Authentication supports both Hindsight Cloud and self-hosted instances, with optional API keys for unauthenticated local setups.

hindsight-integrations/zapier · high confidence

A new \hindsight-zed\ CLI tool (Node.js) is available to configure long-term memory for Zed's AI Agent Panel. Running \hindsight-zed init\ automatically registers the Hindsight MCP server in \settings.json\ and injects a recall/retain instruction into \AGENTS.md\, enabling the agent to load relevant context and store durable facts. The tool supports configuration via environment variables or a local config file, handles JSONC settings safely by providing a manual snippet when comments are present, and includes \status\ and \uninstall\ commands for management.

hindsight-integrations/zed · high confidence

Adds a new integration for the ZCode (Z.ai GLM) coding agent that automatically recalls relevant past context and retains conversation memories to improve long-term assistance. The change introduces a suite of Python modules in the \hindsight-integrations/zcode/hindsight\_zcode/hooks/scripts/lib\ directory, including a REST client for the Hindsight API, configuration management (loading from \settings.json\, \\~/.hindsight/zcode.json\, and environment variables), and daemon lifecycle management to auto-start a local \hindsight-embed\ server if needed. It also includes logic to parse ZCode's JSONL transcript formats, derive stable bank IDs based on agent/project/session, and handle LLM provider detection for local fact extraction.

_hindsight-integrations/cursor-cli, hindsight-integrations/zcode/hindsight\zcode/hooks/scripts · high confidence

Users can now install the \hindsight-agent-framework\ package to give Microsoft Agent Framework agents persistent long-term memory. The integration provides a \HindsightProvider\ context provider that automatically recalls relevant memories before each agent run and retains the conversation afterward, without requiring MCP or tool-calling. It supports both Hindsight Cloud and self-hosted instances, with configuration options for API keys, URLs, recall budgets, and tags.

hindsight-integrations/agent-framework · high confidence

This location introduces the \hindsight-composio\ package, which exposes Hindsight's retain, recall, and reflect operations as custom tools for Composio agents. The integration maps the Composio session's \user\_id\ to a Hindsight memory bank, ensuring per-user memory isolation. It provides a \register\_hindsight\_tools\ function to create these tools and a global \configure\ function for connection settings (API URL, key, default bank, budget, tags). The package includes unit tests for configuration and tool registration, as well as end-to-end tests that verify memory round-trips against a live Hindsight server.

hindsight-integrations/composio · high confidence

The Integrations page has been replaced by a new hub featuring a full-width hero, a search input, and filter pills for official vs. community integrations. The gallery displays integration cards grouped by category, with featured items (coding-agents, Hermes, OpenClaw) pinned at the top when no search or filter is active. It also includes dedicated cards for coding agent harnesses (like Codex) to improve discoverability, and links to changelogs where available.

hindsight-docs/src/pages/integrations · high confidence

Added a new integration for Meta's personal AI agent, Meta Muse, allowing it to connect to Hindsight memory banks over the Model Context Protocol (MCP). This enables Muse to read from and write to Hindsight banks (using tools like \recall\, \retain\, and \reflect\), creating a shared memory layer between Muse and other AI tools. The release includes the integration code, a user-facing connect prompt, documentation, and a preflight tool to verify connectivity and OAuth configuration.

hindsight-integrations/meta-muse · high confidence

A new \hindsight-admin\ CLI tool is introduced to manage PostgreSQL database operations, including backup, restore, migration, and worker management. This tool supports binary COPY-based backup and restore with schema compatibility handling (e.g., dropping missing columns during restore), manages bank aliases, and provides commands for decommissioning workers and checking worker status. It is explicitly PostgreSQL-only and does not support Oracle backends.

_hindsight-api-slim/hindsight\api/admin · high confidence

Users can now install the \hindsight-roo-code\ package to give Roo Code persistent memory capabilities. The integration installs an MCP server configuration and prompt rules that automatically recall relevant context at the start of tasks and retain decisions or summaries at the end. It supports both Hindsight Cloud and self-hosted instances, with installation configurable via a CLI command that writes to \.roo/mcp.json\ and \.roo/rules/\.

hindsight-integrations/roo-code · high confidence

The \hindsight-clients/typescript/generated/core\ directory now contains a complete set of auto-generated TypeScript files (auth, body serialization, parameter building, path/query serialization, and Server-Sent Events support) produced by the \@hey-api/openapi-ts\ tool. This introduces a new HTTP client implementation with built-in support for bearer and basic authentication, configurable body and query serialization (including FormData and URLSearchParams), and robust SSE streaming with retry logic, replacing the previous core client logic.

hindsight-clients/typescript/generated/core · high confidence

This change adds a suite of new scripts in the \scripts/benchmarks/\ directory to automate the execution and publishing of performance data to the continuous performance monitor dashboard. Specifically, it introduces runners for consolidation, document evolution, entity resolution, observation duplication, system performance, semantic within-batch linking, token counting, transfer streaming, and vector serialization benchmarks. Corresponding publish scripts (\publish-locomo-results.sh\, \publish-obs-results.sh\, \publish-perf-results.sh\, \publish-system-evals-results.sh\) enrich these results with commit metadata and push them to the \hindsight-continuous-performance-monitor\ repository. Additionally, \scripts/check-integration-lockfiles.sh\ is added to CI to prevent integration release failures by ensuring npm lockfiles do not resolve to local workspace symlinks.

scripts · high confidence

Added a new benchmarks directory containing evaluation suites for Hindsight's memory system. This includes documentation and entry points for consolidation performance tests, system performance tests (retain throughput and recall latency), multimodal retain benchmarks (testing image retention with vision-capable LLMs), and token counting micro-benchmarks. The README also clarifies that LoComo and LongMemEval datasets are now hosted externally in the AMB repository and provides instructions for running those external benchmarks against local or remote deployments.

hindsight-dev/benchmarks · high confidence

The v0.8 developer documentation has been updated to include comprehensive guides for the new \hindsight-admin\ CLI (covering database migrations, backup/restore, and bank index repair), detailed configuration references for API services and LLM providers, and an extensions guide explaining how to implement custom multi-tenancy, HTTP endpoints, and operation validators.

_hindsight-docs/versioned\docs/version-0.8/developer · high confidence

Added a suite of Python scripts in the \hindsight-dev\ package to support the release and documentation process. The \check\_openapi\_compatibility.py\ script validates OpenAPI specs for breaking changes to ensure API backwards and forwards compatibility. The \cli\_coverage\_check.py\ and \client\_coverage\_check.py\ scripts verify that the Rust CLI and Python/TypeScript SDK wrappers expose all OpenAPI operations and request-body parameters, preventing drift between the spec and client implementations. Additionally, \generate\_changelog.py\ automates changelog generation by analyzing commit diffs and Alembic migrations, \generate\_openapi.py\ exports the FastAPI schema, \generate\_bank\_template\_schema.py\ produces JSON schemas for bank templates, \sync\_cookbook.py\ imports cookbook content from an external repository, and \generate\_llms\_full.py\ concatenates documentation for LLM consumption.

_hindsight-dev/hindsight\dev · high confidence

The documentation site now includes several new static files to support self-hosting and AI agent integration. A JSON Schema (\bank-template-schema.json\) and an OpenAPI specification (\openapi.json\) are provided for bank configuration and API reference. Additionally, four shell scripts (\get-cli\, \get-codex\, \get-mcp\, \get-skill\) are added to simplify the installation of the Hindsight CLI, Codex integration, MCP server, and agent skills. The site also features a new \llms.txt\ file for LLM consumption and an HTML visualization of the mental-model refresh flow.

hindsight-docs/static · high confidence

The documentation site now includes several new React components to enhance content presentation and interactivity. The CodeSnippet component allows embedding specific sections of source code files directly into documentation pages, supporting both Python/Bash and JavaScript/TS comment markers. A new CookbookGrid component provides a filterable card layout for browsing integration examples by topic and SDK. The homepage features a redesigned Hero section with a live, hoverable MemoryConstellation visualization and a live GitHub star count, alongside a HomeFlow component that illustrates the Hindsight architecture with interactive hover-reveal cards for coding agents, personal assistants, and app SDKs. Additionally, HomeBenchmarks displays retrieval accuracy comparisons against next-best systems, and CodingAgentsChart visualizes cost and correction improvements from the Agent Memory Benchmark dataset.

hindsight-docs/src/components · high confidence

The documentation site now uses structured JSON data files to drive its content, replacing ad-hoc or hardcoded lists. A new \featured-posts.json\ file pins specific blog posts (such as the Memlake launch and enterprise features) to the sidebar and index. \integrations.json\ serves as the single source of truth for the integrations gallery and sidebars, listing official and community integrations with their metadata. \llmProviders.json\ and its accompanying TypeScript module define the supported LLM providers, their default models, icons, and capabilities (like batch API support), which are rendered in the docs' provider grid and tables. Finally, \templates.json\ and its associated per-template JSON files (e.g., \business-executive.json\, \coding-agent.json\) define the available memory templates, their categories, and specific retention/reflection missions, allowing users to understand and select pre-configured memory behaviors for different use cases.

hindsight-docs/src/data · high confidence

Added new integration examples for Hindsight in both TypeScript (AI SDK) and Python (LangGraph). The AI SDK example demonstrates how to use \createHindsightTools\ with \generateText\, \streamText\, and \ToolLoopAgent\, including a Next.js API route pattern. The LangGraph example shows how to integrate Hindsight tools into a ReAct agent, build a custom graph with separate recall/retain nodes, and use the new \memory\_instructions\ helper for simpler chain-based setups. Both examples highlight configuration options for memory retention, recall budgets, and metadata tagging.

hindsight-docs/examples/integrations · high confidence

Added comprehensive documentation for the Hindsight v0.7 API and administration. This includes a new Admin CLI guide detailing database migration, backup, restore, and worker decommissioning commands. It also introduces documentation for core API operations (retain, recall, reflect), memory bank configuration (including entity labels and observation settings), document management, mental models (with automatic refresh capabilities), bank templates, and the asynchronous operations system.

_hindsight-docs/versioned\docs/version-0.7 · high confidence

Added two new documentation pages: 'Best Practices' provides practical guidance for integrating Hindsight memory into production systems, covering core concepts like memory banks, taxonomy, and operations (retain, recall, reflect), as well as bank configuration including missions, disposition traits, and entity labels. The 'FAQ' page addresses common questions about Hindsight's architecture, supported clients and LLM providers, hosting options, and specific topics like zombie operation recovery and data isolation strategies.

hindsight-docs/src/pages · high confidence

The \hindsight-extensions\ directory now serves as a registry for unbundled extensions, allowing you to customize the Hindsight API server without forking it. This change introduces two new extensions: a \static-keys-tenant\ extension that authenticates requests using static API keys from environment variables and provides per-user PostgreSQL schema isolation, and a \bank-llm-routing\ extension that allows you to select the LLM and credentials for each call based on bank ID and operation patterns. The registry also includes a \supabase-tenant\ extension (unbundled from the core server) for validating Supabase Auth JWTs. These extensions are shipped by building a Docker image that copies the extension code into the server's import path.

hindsight-extensions · high confidence

The \hindsight-integrations/cline\ directory now contains the \hindsight-cline\ Python package, which integrates Hindsight long-term memory with the Cline coding assistant via lifecycle hooks. Users can install the package via \pip install hindsight-cline\ and run \hindsight-cline install\ to deploy hook scripts (\TaskStart\, \UserPromptSubmit\, \TaskComplete\, \TaskCancel\) that automatically recall relevant memories before tasks and retain task transcripts upon completion. The package includes a CLI for installation and uninstallation, configuration via \\~/.hindsight/cline.json\, and a test suite covering hook logic, bank ID derivation, and content handling.

hindsight-integrations/cline · high confidence

Users can now run \npx @vectorize-io/hindsight-nemoclaw setup\ to automatically install the \hindsight-openclaw\ plugin, configure it for external API mode (pointing to \api.hindsight.vectorize.io\), merge the required Hindsight egress rule into the NemoClaw sandbox's OpenShell network policy, and restart the OpenClaw gateway. The CLI accepts \--sandbox\, \--api-token\, \--bank-prefix\, and optional flags like \--skip-policy\ or \--dry-run\ to preview changes without applying them.

hindsight-integrations/nemoclaw · high confidence

The OpenClaw integration now includes a CLI tool to import existing OpenClaw session history into Hindsight memory banks. The backfill process discovers session files from the OpenClaw root directory, respects the plugin's bank routing configuration (including dynamic bank granularity and agent-specific mappings), and supports resuming interrupted runs via checkpointing. Users can optionally include archived sessions and select specific agents to backfill.

hindsight-integrations/openclaw · high confidence

The documentation site now includes dedicated integration pages for a broad set of new and existing frameworks. New entries cover AG2 (AutoGen) with drop-in tool registration, Microsoft Agent Framework using a context provider, the vendor-neutral Agent Plugins standard for clients like Cursor and VS Code, Amazon Bedrock AgentCore Runtime with stable user-identity banking, Agno via native Toolkits, Vercel AI SDK with five ready-to-use tools, Aider as a CLI wrapper for repo-scoped memory, AutoGen with async-native FunctionTools, Vercel Chat SDK for per-user bot memory, ChatGPT via OAuth-secured MCP connectors, and Anthropic's Claude Agent SDK with both MCP tools and turn-level hooks. Existing pages for Agent Plugins, Amazon Bedrock AgentCore, Agno, Vercel AI SDK, Aider, AutoGen, Vercel Chat SDK, ChatGPT, and Claude Agent SDK have also been added or updated to reflect these capabilities.

hindsight-docs/docs-integrations · high confidence

A new CLI tool (\find-duplicate-observations\) has been added to the \obs\_dedup\ module to identify near-duplicate observations within a Hindsight bank. The tool paginates through the API to fetch observations, re-embeds the text locally using the default \BAAI/bge-small-en-v1.5\ model, and performs a block-wise cosine similarity scan to group similar items into transitive clusters. Users can configure the similarity threshold (default 0.92), minimum cluster size, and output format (console or JSON report) to find redundant entries, with near-verbatim duplicates typically appearing at thresholds of 0.97 or higher.

_hindsight-dev/hindsight\_dev/obs\dedup · high confidence

The storage module now provides a factory-based system for file storage backends, supporting PostgreSQL (native), S3, Google Cloud Storage, and Azure Blob Storage via the obstore library. This change introduces streaming support for large files to avoid holding entire files in memory, implements tenant-scoped key prefixes to prevent cross-tenant collisions in shared object stores, and fixes a bug where GCS download URLs failed for keys containing percent-encoded characters.

_hindsight-api-slim/hindsight\api/engine/storage · high confidence

The \hindsight-docs/examples/api\ directory now contains a comprehensive suite of executable example scripts in Python, Node.js (ESM), Go, and Bash that serve as the source of truth for the product documentation. These scripts demonstrate key API capabilities including bank template import/export and schema retrieval, directive management (create, list, update, delete), document lifecycle operations (retain, update, history, tag management, delete), and bank configuration (retain strategies, MCP tool restrictions). The examples use a marker-based system (\\[docs:section-name\]\) to extract code snippets for MDX documentation and are designed to run as smoke tests against a local Hindsight server, ensuring the documented code remains accurate and functional.

hindsight-docs/examples/api · high confidence

A new performance benchmarking framework has been added to the \hindsight-dev/benchmarks/perf\ directory, providing a structured way to measure and validate system performance. The suite includes a central orchestrator (\system\_perf.py\) that runs independent test suites for the retain pipeline, recall retrieval, graph maintenance, and bank statistics, supporting configurable scales from 'tiny' to 'huge'. It also introduces specific benchmarks for memory usage during document chunking (\retain\_memory.py\) and large-bank recall latency (\recall\_perf.py\), enabling developers to track performance regressions and validate optimizations in a deterministic, LLM-independent environment.

hindsight-dev/benchmarks/perf · high confidence

The v0.10 documentation snapshot now includes detailed guides for the \hindsight-admin\ CLI (covering database migrations, backup/restore, and bank repair/rename operations), declarative Bank Templates for pre-configured memory setup, and core API method references for Retain, Recall, and Reflect. It also documents the Documents API for source tracking and the Knowledge Pages API for living, auto-refreshing markdown documents.

_hindsight-docs/versioned\docs/version-0.10 · high confidence

Version 0.9 of the documentation introduces comprehensive guides for the new \hindsight-admin\ CLI (covering database migrations, backup/restore, and bank index repair), declarative Bank Templates for one-click bank provisioning, and the Knowledge Pages API for managing living markdown documents. It also adds detailed reference pages for core API methods (retain, recall, reflect), memory curation (editing, invalidating, and restoring individual memories), document management, and advanced memory bank configuration including entity labels and observation consolidation.

_hindsight-docs/versioned\docs/version-0.9 · high confidence

The Hindsight API now includes a new webhook subsystem that allows users to register and receive event notifications for consolidation, retain, and memory defense activities. This system introduces hardened outbound delivery to prevent Server-Side Request Forgery (SSRF) by validating destination URLs against private, loopback, and link-local ranges, with an operator-configurable allowlist for internal endpoints. Webhook payloads are signed using HMAC-SHA256 (supporting both standard and timestamped signatures) to ensure integrity and authenticity for receivers. The system supports per-bank and global webhook configurations, queues deliveries asynchronously via an outbox pattern, and includes structured event models with optional SIEM enrichment fields.

_hindsight-api-slim/hindsight\api/webhooks · high confidence

Users with NVIDIA GPUs can now accelerate ONNX-based embeddings by using the new \docker/docker-compose/cuda-onnx\ recipe. This opt-in setup installs \onnxruntime-gpu\ (defaulting to version 1.26.0) and required NVIDIA libraries into a private overlay, enabling the \CUDAExecutionProvider\ via the \HINDSIGHT\_API\_EMBEDDINGS\_ONNX\_DEVICE=cuda\ configuration. The recipe ensures CPU dependencies like \magika\ remain unaffected by installing GPU-specific packages separately, and validates the runtime environment at build time to confirm CUDA availability.

docker/docker-compose/cuda-onnx · high confidence

The memories engine now supports a pluggable storage backend via the \HINDSIGHT\_API\_MEMORIES\_EXTENSION\ configuration. Users can install a custom implementation to replace the default Postgres store, which owns the \memory\_units\, \memory\_links\, \unit\_entities\, \documents\, \chunks\, \entities\, \entity\_cooccurrences\, and \invalidated\_memory\_units\ tables. The new architecture introduces a \MemoriesExtension\ interface and a \PostgresMemories\ implementation that maintains existing behavior, allowing for alternative storage engines while keeping other engine tables (banks, operations) in Postgres.

_hindsight-api-slim/hindsight\api/engine/memories · high confidence

A new portable Agent Plugin (spec 1.0.0) is available for Hindsight, providing long-term memory capabilities via the Agent Plugins standard. This plugin bundles the Hindsight MCP server configuration, a memory skill definition, and a validation script, allowing compatible agent clients (such as VS Code, Cursor, GitHub Copilot, and ChatGPT) to access Hindsight's retain, recall, and reflect tools through a single, standards-based artifact. It supports configuration via environment variables for API keys and bank scoping, though it is explicitly noted as incompatible with Codex due to header handling limitations.

hindsight-integrations/agent-plugin · high confidence

Operators can now control which LLM provider, model, and API credentials are used for each bank's calls by defining JSON routes in the HINDSIGHT\_API\_LLM\_REQUEST\_ROUTES environment variable. Routes match banks (with optional schema, operation, provider, and model filters) and allow overriding the LLM entirely or just supplying a specific API key and custom headers. If no route matches a bank, the system can either refuse the call (default) or fall back to the server's default LLM configuration via HINDSIGHT\_API\_LLM\_REQUEST\_UNMATCHED.

hindsight-ext-bank-llm-routing · high confidence

The documentation sidebar now renders custom icons before or after link labels, allowing for visual distinction of different content types (e.g., language support, tools, or external resources) via a predefined set of Lucide and Simple Icons. Additionally, blog posts can now be displayed as featured items with a cover image thumbnail and date, providing a more visual and compact presentation in the sidebar.

hindsight-docs/src/theme/DocSidebarItem · high confidence

This release publishes the complete v1.0 documentation set, introducing new guides for Hindsight Enterprise (including Memlake storage and deployment options), Hindsight Cloud, and the Admin CLI. It also adds detailed API reference pages for Bank Templates, Documents, Knowledge Pages, and Memories, providing users with comprehensive instructions for managing memory banks, curating facts, and organizing knowledge.

_hindsight-docs/versioned\docs/version-1.0 · high confidence

The benchmarking infrastructure for the Entity-Aware Memory System has been removed. This change deletes the \benchmarks/\ directory, including the \README.md\ documentation, the \locomo/\ and \longmemeval/\ subdirectories, and all associated runner scripts (\run\_benchmark.py\), datasets (\locomo10.json\, \longmemeval\_s\_cleaned.json\), and result files (\benchmark\_results.json\). Users can no longer execute the LoComo or LongMemEval evaluations to test long-term conversational memory capabilities.

benchmarks · high confidence

The bundled frontend assets for the network visualization and dropdown components have been removed. Specifically, the custom JavaScript bindings in \lib/bindings/utils.js\ (which handled node highlighting and filtering logic) and the Tom Select library (\lib/tom-select/tom-select.complete.min.js\ and \tom-select.css\) are no longer included. Additionally, the CSS styles for the vis-network library (\lib/vis-9.1.2/vis-network.css\) have been deleted. This change eliminates the local dependencies on these specific UI and visualization assets.

lib/bindings, lib/tom-select, lib/vis-9.1.2 · high confidence

The interactive HTML graph visualization feature has been removed from the application. This change deletes the Python script responsible for generating the graph from the memory database, along with the frontend JavaScript bindings and CSS styles for the visualization library (vis-network) and the dropdown selector (tom-select).

visualizations · high confidence

The entire \memory\ package has been removed from the codebase. This deletion eliminates the previous implementation of the AI agent's memory system, which included temporal and semantic memory storage, coreference and entity resolution, LLM-based fact extraction, and memory visualization tools.

memory · high confidence

The Python client library has been regenerated to match the OpenAPI specification version 1.0.0, introducing new data models for bank templates (BankTemplateManifest, BankTemplateDirective, BankTemplateMentalModel), bank aliases (BankAliasEntry), and audit logging (AuditLogEntry, AuditLogStatsBucket, AuditLogSummary). It also adds support for chunked content with attachments (ChunkData, ChunkAttachment), consolidated scope patterns (ConsolidationScopePattern), and inline base64 attachments (Base64AttachmentSource), ensuring the client can handle the latest API structures for bank configuration, mental model templates, and document processing.

hindsight-client · high confidence

The Postgres-specific SQL queries for the memory engine have been extracted from the main engine code into a dedicated \hindsight\_api/engine/memories/pg\ package. This new structure organizes the database operations into separate modules by concern—such as \admin\ for operator-side gauges, \consolidation\ for write locks and dedup, \curation\ for list/detail views, \documents\ for chunk and attachment handling, and \reads\/\writes\ for core memory operations. This refactoring isolates the database dialect logic, making the queries easier to maintain and allowing the core engine to delegate store-specific SQL to these modular components.

_hindsight-api-slim/hindsight\api/engine/memories/pg · high confidence

The documentation theme now includes new wrapper components and styles for the DocItem content area. Specifically, a new \DocItemContent\ wrapper component and associated CSS styles (\.docItemHeader\, \.docItemActions\) have been added to \hindsight-docs/src/theme/DocItem/Content\. These files currently act as pass-through wrappers for the original Docusaurus theme without implementing any visible behavioral changes or new UI features yet, likely serving as a foundation for future customizations.

hindsight-docs/src/theme/DocItem · medium confidence

The documentation site now uses a new custom CSS theme (\custom.css\) that replaces default styling with a modern blue-to-teal gradient palette, specific typography (Inter, Space Grotesk, JetBrains Mono), and a 4rem navbar height. This change introduces full dark mode support, adjusting colors for backgrounds, text, and interactive elements like the hero band and skill banner to ensure readability and visual consistency across both light and dark themes.

hindsight-docs/src/css · high confidence

When viewing a blog post with a table of contents, the layout now displays a sticky left rail containing the page's headings and a 'Try Hindsight Cloud' call-to-action, while a 'Back to top' button is fixed in the bottom-right corner. List pages without a table of contents retain the previous centered column layout. This change overrides the previous behavior where the table of contents was hidden by default, ensuring navigation aids are visible for detailed posts.

hindsight-docs/src/theme/BlogLayout · high confidence

The documentation theme now conditionally renders a SkillBanner component below the breadcrumbs. This banner is hidden on the homepage to preserve the full-bleed hero design, but appears on all other documentation pages.

hindsight-docs/src/theme/DocBreadcrumbs · high confidence

The documentation theme now applies specific layout rules for cookbook pages and integrates a new skill banner. For pages under the /cookbook path, the main content area expands to full width, and the sidebar is hidden entirely. For all other pages, a SkillBanner component is rendered above the standard sidebar.

hindsight-docs/src/theme/DocPage · high confidence

The auto-generated client in \hindsight-clients/typescript/generated/client\ has been updated to be compatible with the Deno runtime. This change introduces specific handling within the request execution logic to exclude internal \hey-api\ fields (such as \client\) that conflict with Deno's \RequestInit\ interface, ensuring the generated code runs correctly in both Node.js and Deno environments without modification.

hindsight-clients/typescript/generated/client · high confidence

The Hindsight memory provider is no longer bundled inside the Hermes Agent core; it is now a standalone plugin installed from the Hermes plugin catalog. Existing users are unaffected: the provider automatically migrates on next startup, and all memory data (banks, profiles, and embedded PostgreSQL instances) remains in place. The plugin supports cloud, local-embedded, and local-external modes, with the embedded daemon now running out-of-process to avoid dependency conflicts and reduce install size. Configuration is managed via the standard setup wizard or environment variables, and updates are controlled through the catalog pin or explicit commit refs.

hindsight-integrations/hermes · high confidence

The \hindsight-api-slim\ package now uses lazy loading for its public API, deferring the import of heavy engine and search components until they are actually accessed. This prevents the application from blocking on startup and avoids the worker-spawn failures that occurred when multiple event loops tried to import the full stack simultaneously. Additionally, the package now automatically caps native ML thread pools (OpenBLAS, OpenMP, MKL) based on the process's actual CPU budget, preventing oversubscription and improving throughput in containerized environments.

_hindsight-api-slim/hindsight\api · high confidence

The search interface has been relocated from the top navigation bar to the top of the documentation sidebar. This change frees up space in the navbar and keeps the search functionality contextually aligned with the documentation navigation. The search field is now styled to fit within the sidebar layout, including adjustments for the search hint shortcut and results panel positioning.

hindsight-docs/src/theme/DocSidebar · high confidence

The Python client library stubs in \hindsight-clients/python/hindsight\_client\_api/api\ have been regenerated to match the OpenAPI document version 1.0.0. This update refreshes the generated API classes—including \AuditApi\, \BankTemplatesApi\, \BankTransferApi\, \BanksApi\, \DirectivesApi\, \DocumentTransferApi\, and \DocumentsApi\—ensuring they align with the current server-side API contract. Users relying on this client will see updated method signatures and response types that reflect the latest API specification.

_hindsight-clients/python/hindsight\_client\api/api · high confidence

The Python client models in \hindsight\_client\_api/models\ have been regenerated to match the OpenAPI specification version 1.0.0. This update introduces a comprehensive set of Pydantic model classes covering the full API surface, including bank configuration and profile responses, bank alias management, consolidated statistics, mental model operations (refresh, dry-run, triggers), document handling (export, import, history, chunks), and async operation tracking. The generated code now includes explicit support for new capabilities such as per-bank LLM health probes, bank template configurations, and structured recall scoring, ensuring the client library accurately reflects the current server-side API contracts.

_hindsight-clients/python/hindsight\_client\api/models · high confidence

The blog landing page now features a new UI that allows users to filter posts by category (Hindsight Cloud, Deep Dives, Announcements & Releases, Tutorials & Integrations) and search by title or description. The page implements infinite scrolling for post lists and includes a dedicated section for pinned featured posts. Additionally, the tag archive pages have been updated to match this new design, providing a consistent browsing experience across the blog.

hindsight-docs/src/theme/BlogListPage · high confidence

The blog post header component has been updated to display the frontmatter description as a subtitle beneath the post title, followed by a unified byline row showing author avatars and names alongside the date. This new layout replaces the previous vertical stacking of title, info, and authors, providing a more compact and visually distinct header for individual blog post pages while preserving the original layout for list views.

hindsight-docs/src/theme/BlogPostItem · high confidence

The TypeScript client in \hindsight-clients/typescript/generated\ has been regenerated to reflect the latest API surface. This update includes new types and SDK methods for features such as bank aliases, document history, knowledge base management, and audit logging, ensuring the client matches the current server endpoints.

hindsight-clients/typescript/generated · high confidence

The documentation site's top navigation bar and mobile sidebar have been redesigned to improve layout and usability. The desktop navbar now groups 'Docs' and version selection into a single visual unit, positions the sign-up call-to-action distinctly on the right, and includes a color mode toggle that is hidden on smaller viewports. The mobile sidebar has been restructured with a dedicated header containing the logo, color toggle, and close button, alongside separate primary and secondary menus with a back-button for navigation. Additionally, the navbar now supports a hide-on-scroll behavior for a cleaner reading experience.

hindsight-docs/src/theme/Navbar · high confidence

The documentation sidebar has been enhanced to improve content discoverability. Featured blog posts are now pinned to the top of the sidebar across all versions, ensuring key announcements remain visible. Additionally, the Integrations section has been restructured: a single source of truth (integrations.json) now drives the sidebar, replacing the previous placeholder with a grouped, alphabetically sorted list of integrations organized by category (coding agents, frameworks, apps) without requiring per-version sidebar edits.

hindsight-docs/src/theme/DocRoot · high confidence

The documentation site now uses a single source of truth for coding agent harnesses, centralizing the list of supported agents (including Claude Code, Codex, Cursor, GitHub Copilot CLI, Qwen Code, ZCode, and others) in \coding-agent-harnesses.ts\. This roster drives both the integrations gallery and the sidebar previews, ensuring that adding a new harness updates all surfaces simultaneously. The integration sidebar has been reorganized into distinct groups—Coding agents, Frameworks & SDKs, Apps & tools, and Legacy—with curated previews and a dedicated section for superseded plugins. Integration data is now sorted alphabetically by name and grouped by category, improving discoverability and consistency across the gallery and sidebars.

hindsight-docs/src/lib · high confidence

The Alembic migration system now supports both PostgreSQL and Oracle 23ai through a unified revision tree, using a dialect dispatcher to route schema changes to the appropriate backend-specific logic. For PostgreSQL, provisioning new tenant schemas is significantly faster because index creation on empty schemas runs without CONCURRENTLY, avoiding stalls caused by long-running transactions in other schemas. Additionally, deployments can now take ownership of specific maintenance routines by setting the HINDSIGHT\_API\_EXTERNALLY\_OWNED\_ROUTINES environment variable, preventing migrations from overwriting custom implementations.

_hindsight-api-slim/hindsight\api/alembic · high confidence

This release applies a suite of Alembic migrations to the PostgreSQL database to improve performance, fix schema inconsistencies, and enhance search capabilities. Key changes include adding a composite index on memory\_links(bank\_id, link\_type) to accelerate bank-scoped stats queries, making memory\_links foreign keys deferrable to prevent deadlocks during concurrent writes, and widening bank\_id columns in directives and mental\_models tables from VARCHAR(64) to TEXT to support longer identifiers. Search improvements involve recreating the entities trigram index for case-insensitive matching, scoping the trigram index by bank to reduce fuzzy match latency, adding a GIN index on source\_memory\_ids for faster observation lookups, and introducing a text\_signals column to memory\_units to enrich BM25 full-text search. Additionally, the system now tracks consolidation failures via a new column to prevent silent data loss, repairs missing columns in the mental\_models table for certain upgrade paths, and merges divergent migration heads to ensure a linear upgrade path.

_hindsight-api-slim/hindsight\api/alembic/versions · high confidence

The OpenClaw plugin's smoke test now correctly detects plugin failures in OpenClaw 2026.9.x by replacing fragile word-based diagnostics checks with a strict rule that any diagnostic mentioning the plugin is a failure. The test also runs non-interactively and fails if any 'hindsight doctor' diagnostic is present. Additionally, a new packaging script ensures devDependencies are stripped from the published manifest to prevent npm install crashes caused by vitest peer dependency resolution issues.

hindsight-integrations/openclaw/scripts · high confidence

The Hermes plugin now runs the embedded Hindsight daemon as a separate out-of-process component rather than importing it directly, which resolves dependency conflicts (such as protobuf and pydantic version mismatches) that previously prevented the plugin from loading in certain environments. To ensure reliable startup, the plugin now launches the daemon via a clean child process that explicitly strips interpreter-specific environment variables like PYTHONPATH, preventing import errors caused by environment pollution. Additionally, the plugin provides specific repair hints pointing users to 'hermes pm repair' if required packages are missing, and introduces a configurable timeout for waiting on the daemon's health check to accommodate slower systems.

hermes-plugin-hindsight · high confidence

The standalone Docker image now supports building API-only, Control Plane-only, or both via Docker targets, with the Node runtime upgraded to LTS 24 and vulnerable packages removed from runtime images. The startup script includes pre-flight checks for embedded pg0 database integrity and directory writability to prevent data loss and permission errors, and it now respects the API's model initialization timeout to avoid premature container termination during model downloads. The Control Plane correctly binds to loopback addresses to prevent locale rewrite issues, and the image is built to be free of fixed HIGH CVEs.

docker/standalone · high confidence

1236 commits adding/updating tests in hindsight-api-slim/tests; Added Docker smoke test scripts for validating image health; Added Go client API service tests; Added integration and structural tests for the Hindsight CLI; Added integration and unit tests for Hindsight embedded client and server lifecycle; Added integration tests for OpenClaw plugin hooks and Hindsight client interactions; Added integration tests for reverse proxy, MCP, and Hermes embedded modes; Added test coverage for the Hermes memory plugin; Added test suite for hindsight-embed; Added test suite for the Hindsight AgentCore integration; Added tests for Agno integration configuration and tools; Added tests for Hindsight AutoGen integration tools; Added tests for bank ID derivation and plugin behavior; Added tests for dev script root resolution and changelog generation; Added tests for the Google ADK Hindsight integration; Added tests for the Hindsight Codex CLI integration; Added tests for the Hindsight Grok Bot plugin integration; Added unit and end-to-end tests for the Hindsight OpenAI Agents integration; Added unit and live integration tests for the Pipecat memory service; Added unit tests for AG2 integration tools; Added unit tests for CrewAI integration configuration, storage, and tools; Added unit tests for Hindsight Strands configuration and tools; Added unit tests for SmolAgents integration configuration and tools; Added unit tests for control-plane API routes; Added unit tests for control-plane client and library utilities; Added unit tests for the n8n Hindsight integration; Added upgrade and backwards compatibility tests; Expanded test coverage for the Hindsight Python client; Expanded test coverage for the TypeScript client SDK; Initial test suite for the Hindsight Claude Code plugin; New blackbox system-test suite for integration scenarios; New microbenchmark suite for core performance hotspots; Removal of test suite and fixtures.

This change introduces several new packages to the Hindsight ecosystem: \hindsight-all\ (a Node.js lifecycle manager for the embedded daemon), \hindsight-all-slim\ and \hindsight-all\ (Python all-in-one bundles), and \hindsight-api-slim\ (the core Python API). It also adds official client SDKs for TypeScript (\@vectorize-io/hindsight-client\), Python (\hindsight-client\), and Rust (\hindsight-client\), alongside a new Rust-based CLI (\hindsight-cli\). Additionally, it defines extension packages for Supabase, static-keys tenant, and bank-LLM routing, and updates the control plane to use Next.js 16.3.8.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 44.

• Code Health 59
• Architecture 92
• Maturity 55
• Readiness 35
• Security 63
• Domain Modelling 100
• Accessibility 43
• Performance 69

• 300 commits — 151 feature/other, 149 fixes

• hindsight-api-slim/hindsight_api — 105 commits
• hindsight-api-slim/tests — 33 commits
• hindsight-control-plane/src — 23 commits
• hindsight-docs/src — 13 commits
• hindsight-integrations/coding-agents — 11 commits
• hindsight-integrations/hermes — 10 commits
• hindsight-integrations/openclaw — 9 commits
• (root) — 7 commits
• hindsight-docs/blog — 6 commits
• hindsight-clients/python — 4 commits
• hindsight-embed/hindsight_embed — 4 commits
• hindsight-docs/docs — 3 commits
• hindsight-docs/docs-integrations — 3 commits
• .github/workflows — 2 commits
• helm/hindsight — 2 commits
• hindsight-clients/go — 2 commits
• hindsight-integrations/claude-agent-sdk — 2 commits
• hindsight-integrations/cloudflare-oauth-proxy — 2 commits
• hindsight-integrations/cursor — 2 commits
• hindsight-integrations/eliza — 2 commits

• fix: Revert "fix(api): consolidation discovery probe, mental-model edit race, LlamaParse v2 (#5513)"
• fix: chore(consolidation): drop the unused any_memory_exists, fix a stale comment (#5430)
• fix: fix(anthropic): fail fast on refusal stop_reason instead of retrying as invalid JSON (#5616)
• fix: fix(api): 404 any store call for a bank deleted by another process within the cache TTL (#5432)
• fix: fix(api): a refresh cut off during a retry backoff no longer pauses automatic refresh (#5561) (#5745)
• fix: fix(api): a store that sheds a request answers 503 + Retry-After, not 500 (#5527)
• fix: fix(api): cancel a sync retain when its client disconnects (#5358)
• fix: fix(api): close bank-validator gaps from #5448 (#5663)
• fix: fix(api): consolidation discovery probe, mental-model edit race, LlamaParse v2 (#5513)
• fix: fix(api): don't warn with a traceback when alias resolution hits a missing API key (#5409)
• fix: fix(api): honor a systemd CPUQuota and bound ONNX Runtime threads (#5725) (#5779)
• fix: fix(api): measure durations with a monotonic clock, ban time.time() via ruff (#5662)
• fix: fix(api): port the LlamaParse connector to the v2 parse API (#5659)
• fix: fix(api): probe banks for consolidation work without seq-scanning memory_units (#5672)
• fix: fix(api): re-check mental-model edits under the row lock so the vector matches the stored text (#5619)
• fix: fix(api): refuse tag-scoped callers on operations answered for the whole bank (#5463)
• fix: fix(api): retain prose 'no facts', claude-code JSON repair, codex stream errors, provider spans, claude-code ToS docs (#5516)
• fix: fix(api): return consolidation state on GET /memories/{id} (#5767)
• fix: fix(api): stop a big graph read from freezing the event loop (#5703) (#5782)
• fix: fix(api): stop an abandoned reflect mid-call when its client disconnects (#5610)
• …and 280 more

• 0 containers · 20 bounded contexts · 0 dependency edges (baseline)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

vectorize-io/hindsight was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.