mirror of
https://github.com/vectorize-io/hindsight.git
synced 2026-09-14 19:31:49 +08:00
Nicolò Boschi
280f098202
Makes images and files first-class raw content in `retain`. `content` accepts an ordered list of text/image/file blocks, the extractor reads each attachment in the position it occupies, and every read surface hands back the attachments behind what it returns. A plain string behaves exactly as before — text-only retain is byte-identical, because everything new sits behind an ATTACHMENTS block that is empty when a chunk carries none. Blocks are flattened at the API boundary into one canonical body with atomic placeholders, so `documents.original_text` stays plain text and content_hash idempotency, `update_mode=append`, chunk-delta re-extraction and `reprocess_document` keep working untouched. Bytes live in the existing FileStorage abstraction, content-addressed by sha256. Schema (one migration, both dialects): `attachments` for the blob, `document_attachments` for which documents reference it, and `memory_units.attachment_ids` for which attachments a *fact* came from — a column rather than a third table, because those ids behave exactly like `tags`. Provenance is per fact, not per chunk. Extraction runs one call per chunk, and a chunk holding a screenshot also holds the prose around it, so a chunk-level edge cited the diagram as evidence for the paragraph that never mentioned it. The extractor is asked instead, and a fact stated in the prose carries nothing. Extraction quality was measured against a real image-QA dataset with a raw-VLM ceiling arm before merging: transcribing structured attachments rather than summarizing them, and recording how each value is drawn, took the gap between "the model can read this off the image" and "memory can answer it" from 31.3% to 10.0% on the same 40 charts. The prose-article benchmark went 75% -> 100% over the same change, so it is not chart-specific tuning. Also here: * A vision slot (`HINDSIGHT_API_VLM_*`) so attachment-bearing chunks alone use a vision model and text-only chunks stay on a cheaper retain LLM. A vision call deliberately does not fail over to the retain chain's text models — that would reintroduce the silent omission the 422 gate exists to prevent. * The extension retain hook can now see each attachment (media type, size, kind, filename) and refusing a retain reclaims its bytes, which previously stayed fetchable forever. * A filename lives on the document edge, not the blob: the same PDF can be attached under a different name elsewhere, and content-addressing made the first name win for both. Known limitations, documented rather than hidden: store-owned memory backends get nothing (that retain path is Postgres-free and pre-dates this work), very dense pages are sampled rather than exhausted, and the Python client's ContentBlock is a plain dict where TypeScript gets the real union. Breaking for Go and Rust callers: `content` is now a union, so a bare string no longer satisfies it. Go gains a `TextContent()` helper; Rust uses `Content::Variant0(...)`.
91 lines
2.4 KiB
Go
91 lines
2.4 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
"time"
|
|
|
|
hindsight "github.com/vectorize-io/hindsight/hindsight-clients/go"
|
|
)
|
|
|
|
func main() {
|
|
apiURL := os.Getenv("HINDSIGHT_API_URL")
|
|
if apiURL == "" {
|
|
apiURL = "http://localhost:8888"
|
|
}
|
|
|
|
// [docs:quickstart-full]
|
|
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: hindsight.TextContent("Alice works at Google")},
|
|
},
|
|
}
|
|
client.MemoryAPI.RetainMemories(ctx, "my-bank").RetainRequest(retainReq).Execute()
|
|
|
|
// Recall memories
|
|
recallReq := hindsight.RecallRequest{
|
|
Query: "What does Alice do?",
|
|
}
|
|
resp, _, _ := client.MemoryAPI.RecallMemories(ctx, "my-bank").RecallRequest(recallReq).Execute()
|
|
for _, r := range resp.Results {
|
|
fmt.Println(r.Text)
|
|
}
|
|
|
|
// Reflect - generate response
|
|
reflectReq := hindsight.ReflectRequest{
|
|
Query: "Tell me about Alice",
|
|
}
|
|
answer, _, _ := client.MemoryAPI.Reflect(ctx, "my-bank").ReflectRequest(reflectReq).Execute()
|
|
fmt.Println(answer.GetText())
|
|
// [/docs:quickstart-full]
|
|
|
|
// Cleanup (not shown in docs)
|
|
req, _ := http.NewRequest("DELETE", fmt.Sprintf("%s/v1/default/banks/my-bank", apiURL), nil)
|
|
http.DefaultClient.Do(req)
|
|
|
|
// [docs:nullable-fields]
|
|
// Creating nullable values
|
|
timestamp := time.Date(2024, 1, 15, 10, 0, 0, 0, time.UTC)
|
|
retainReq2 := hindsight.RetainRequest{
|
|
Items: []hindsight.MemoryItem{
|
|
{
|
|
Content: hindsight.TextContent("Alice got promoted"),
|
|
Context: *hindsight.NewNullableString(hindsight.PtrString("career update")),
|
|
Timestamp: *hindsight.NewNullableTimestamp(&hindsight.Timestamp{TimeTime: hindsight.PtrTime(timestamp)}),
|
|
Tags: []string{"career"},
|
|
},
|
|
},
|
|
}
|
|
retainResp, _, _ := client.MemoryAPI.RetainMemories(ctx, "my-bank").RetainRequest(retainReq2).Execute()
|
|
|
|
// Checking if a value is set
|
|
if retainResp.HasOperationId() {
|
|
fmt.Println("OperationId:", retainResp.GetOperationId())
|
|
}
|
|
// [/docs:nullable-fields]
|
|
|
|
// [docs:error-handling]
|
|
_, httpResp2, err := client.MemoryAPI.RecallMemories(ctx, "my-bank").
|
|
RecallRequest(recallReq).
|
|
Execute()
|
|
|
|
if err != nil {
|
|
log.Fatalf("Recall failed: %v", err)
|
|
}
|
|
defer httpResp2.Body.Close()
|
|
// [/docs:error-handling]
|
|
|
|
fmt.Println("quickstart.go: All examples passed")
|
|
}
|