changelog for 0.4.12

hindsight-docs/blog/2026-02-18-version-0-4-12.md

@@ -0,0 +1,141 @@
+---
+title: "What's new in Hindsight 0.4.12"
+description: New features and improvements in Hindsight 0.4.12
+authors: [hindsight]
+date: 2026-02-18
+---
+
+Hindsight 0.4.12 expands what you can ingest, cuts ingestion costs, and broadens where you can run it.
+
+- [**File Ingestion**](#file-ingestion): Retain PDFs, images, and Office documents directly.
+- [**Batch API for Async Retain**](#batch-api-for-async-retain): Cut LLM ingestion costs by 50% using OpenAI and Groq Batch APIs.
+- [**Go Client SDK**](#go-client-sdk): Idiomatic Go client with functional options and full API coverage.
+- [**DiskANN Vector Indexing**](#diskann-vector-indexing): pgvectorscale and Azure pg_diskann support for large-scale deployments.
+
+<!-- truncate -->
+
+## Upgrade Today
+
+```bash
+# Docker
+docker pull ghcr.io/vectorize-io/hindsight:0.4.12
+
+# Python SDK
+pip install --upgrade hindsight-sdk
+```
+
+## File Ingestion
+
+Hindsight can now retain PDFs, images, and common Office documents (DOCX, PPTX, XLSX) directly—without you needing to extract text first.
+
+```python
+from hindsight_sdk import HindsightClient
+
+client = HindsightClient()
+
+# Retain a PDF
+with open("report.pdf", "rb") as f:
+    client.retain_files("my-bank", files=[("file", ("report.pdf", f, "application/pdf"))])
+
+# Retain an image
+with open("screenshot.png", "rb") as f:
+    client.retain_files("my-bank", files=[("file", ("screenshot.png", f, "image/png"))])
+```
+
+Or use the REST endpoint directly:
+
+```bash
+curl -X POST http://localhost:8888/v1/default/banks/my-bank/files/retain \
+  -F "[email protected];type=application/pdf"
+```
+
+Two file parsers are available: **Markitdown** (the default) and the new **Iris** parser, which provides improved extraction quality for complex documents. Switch parsers with:
+
+```bash
+export HINDSIGHT_API_FILE_PARSER=iris  # or markitdown (default)
+```
+
+## Batch API for Async Retain
+
+When using async retain, you can now cut your LLM costs by 50% by enabling the provider Batch API. OpenAI and Groq both offer a 50% discount on token pricing for batch workloads in exchange for a processing window of up to 24 hours.
+
+```bash
+export HINDSIGHT_API_RETAIN_BATCH_ENABLED=true
+```
+
+This requires async retain (`async=true` in your request). Hindsight submits fact extraction calls as a batch job to the provider, polls for completion, and processes results automatically. Because retain runs in the background anyway, the delayed processing window is typically invisible to end users.
+
+This is the most impactful cost optimization for workloads that ingest large volumes of content—backfills, document libraries, conversation archives.
+
+Reliability improvements in this release also ensure that large payloads are handled correctly throughout the batch lifecycle, and document tags are preserved when using the async retain flow.
+
+## Go Client SDK
+
+Hindsight now has a Go client, generated from the OpenAPI 3.1 spec using [OpenAPI Generator](https://github.com/OpenAPITools/openapi-generator).
+
+```go
+import hindsight "github.com/vectorize-io/hindsight/hindsight-clients/go"
+
+cfg := hindsight.NewConfiguration()
+cfg.Servers = hindsight.ServerConfigurations{
+    {URL: "http://localhost:8888"},
+}
+client := hindsight.NewAPIClient(cfg)
+ctx := context.Background()
+
+// Retain a memory
+retainReq := hindsight.RetainRequest{
+    Items: []hindsight.MemoryItem{
+        {Content: "The deployment succeeded at 14:32 UTC.", Tags: []string{"ops"}},
+    },
+}
+client.MemoryAPI.RetainMemories(ctx, "my-bank").RetainRequest(retainReq).Execute()
+
+// Recall memories
+recallReq := hindsight.RecallRequest{Query: "recent deployments"}
+resp, _, _ := client.MemoryAPI.RecallMemories(ctx, "my-bank").RecallRequest(recallReq).Execute()
+for _, r := range resp.Results {
+    fmt.Println(r.Text)
+}
+```
+
+See the [Go SDK documentation](/sdks/go) for the full reference.
+
+## DiskANN Vector Indexing
+
+Two new vector indexing backends are available for large-scale deployments:
+
+**pgvectorscale (DiskANN)** — high-performance approximate nearest neighbor search for self-hosted deployments:
+
+```bash
+# Use the TimescaleDB + DiskANN docker-compose example
+docker compose -f docker/docker-compose/timescale/docker-compose.yml up
+```
+
+**Azure pg_diskann** — native DiskANN indexing for Azure Database for PostgreSQL – Flexible Server, with no additional infrastructure required.
+
+Configure the index backend via environment variable:
+
+```bash
+export HINDSIGHT_API_VECTOR_INDEX_BACKEND=diskann        # pgvectorscale
+export HINDSIGHT_API_VECTOR_INDEX_BACKEND=azure_diskann  # Azure pg_diskann
+```
+
+Both backends are drop-in replacements for the default pgvector index, providing better recall performance at scale without changing the API.
+
+## Other Updates
+
+- **AI SDK tooling**: The Vercel AI SDK integration has been simplified and improved, with better TypeScript types and cleaner tool definitions.
+- **Python client**: Async API consistency improvements and keepalive timeout fixes reduce connection drop issues under load.
+- **OpenClaw hardening**: Safer shell handling (`execFile` instead of `exec`), HTTP dual-mode communication, per-user bank isolation, and more reliable reinitialization with cooldown logic.
+
+## Feedback and Community
+
+Hindsight 0.4.12 is a drop-in replacement for 0.4.x with no breaking changes.
+
+Share your feedback:
+
+- [GitHub Discussions](https://github.com/vectorize-io/hindsight/discussions)
+- [GitHub Issues](https://github.com/vectorize-io/hindsight/issues)
+
+For detailed changes, see the [full changelog](/changelog).

hindsight-docs/docs/developer/api/retain.mdx

@@ -157,6 +157,20 @@ For large batches, use async ingestion to avoid blocking:
 </TabItem>
 </Tabs>
 
+### Cut Costs 50% with Provider Batch APIs
+
+When using async retain, enable the provider Batch API to reduce LLM fact-extraction costs by 50%. OpenAI and Groq both offer this discount in exchange for a processing window of up to 24 hours — a trade-off that's typically invisible when retain already runs in the background.
+
+```bash
+export HINDSIGHT_API_RETAIN_BATCH_ENABLED=true
+```
+
+Hindsight submits fact extraction calls as a batch job to the provider, polls for completion, and processes results automatically. No changes to your API calls are needed.
+
+:::note
+Batch API cost savings require `async=true` in your retain request and a compatible provider (OpenAI or Groq).
+:::
+
 ## Tagging Memories
 
 Tags enable **visibility scoping**—useful when one memory bank serves multiple users but each should only see relevant memories. For example, an agent that chats with multiple users can tag memories by user ID and filter during recall.

hindsight-docs/docs/developer/performance.md

@@ -142,6 +142,7 @@ Hindsight uses PostgreSQL with pgvector for efficient vector search:
 
 ### Cost Optimization
 - **Use efficient models**: `gpt-oss-20b` via Groq for retain — Hindsight doesn't need frontier models
+- **Enable provider Batch API**: Set `HINDSIGHT_API_RETAIN_BATCH_ENABLED=true` with async retain to cut LLM fact-extraction costs by 50% (supported on OpenAI and Groq; results delivered within 24 hours)
 - **Control token budgets**: Limit `max_tokens` for recall, use lower budgets when possible
 - **Optimize chunks**: Larger chunks (1000-2000 tokens) are more efficient than many small ones
 

hindsight-docs/src/pages/changelog.md

@@ -8,6 +8,30 @@ This changelog highlights user-facing changes only. Internal maintenance, CI/CD,
 
 For full release details, see [GitHub Releases](https://github.com/vectorize-io/hindsight/releases).
 
+## [0.4.12](https://github.com/vectorize-io/hindsight/releases/tag/v0.4.12)
+
+**Features**
+
+- Accept and ingest PDFs, images, and common Office documents as inputs. ([`224b7b74`](https://github.com/vectorize-io/hindsight/commit/224b7b74))
+- Add the Iris file parser for improved document parsing support. ([`7eafba66`](https://github.com/vectorize-io/hindsight/commit/7eafba66))
+- Add async Retain support via provider Batch APIs (e.g., OpenAI and Groq) for higher-throughput ingestion. ([`40d42c58`](https://github.com/vectorize-io/hindsight/commit/40d42c58))
+- Allow Recall to return chunks only (no memories) by setting max_tokens=0. ([`7dad9da0`](https://github.com/vectorize-io/hindsight/commit/7dad9da0))
+- Add a Go client SDK for the Hindsight API. ([`2a47389f`](https://github.com/vectorize-io/hindsight/commit/2a47389f))
+- Add support for the pgvectorscale (DiskANN) vector index backend. ([`95c42204`](https://github.com/vectorize-io/hindsight/commit/95c42204))
+- Add support for Azure pg_diskann vector indexing. ([`476726c2`](https://github.com/vectorize-io/hindsight/commit/476726c2))
+
+**Improvements**
+
+- Improve reliability of async batch Retain when ingesting large payloads. ([`aefb3fcf`](https://github.com/vectorize-io/hindsight/commit/aefb3fcf))
+- Improve AI SDK tooling to make it easier to work with Hindsight programmatically. ([`d06a0259`](https://github.com/vectorize-io/hindsight/commit/d06a0259))
+
+**Bug Fixes**
+
+- Ensure document tags are preserved when using the async Retain flow. ([`b4b5c44a`](https://github.com/vectorize-io/hindsight/commit/b4b5c44a))
+- Fix OpenClaw ingestion failures for very large content (E2BIG). ([`6bad6673`](https://github.com/vectorize-io/hindsight/commit/6bad6673))
+- Harden OpenClaw behavior (safer shell usage, better HTTP mode handling, and more reliable initialization), including per-user banks support. ([`c4610130`](https://github.com/vectorize-io/hindsight/commit/c4610130))
+- Improve Python client async API consistency and reduce connection drop issues via keepalive timeout fixes. ([`8114ef44`](https://github.com/vectorize-io/hindsight/commit/8114ef44))
+
 ## [0.4.11](https://github.com/vectorize-io/hindsight/releases/tag/v0.4.11)
 
 **Features**