Hindsight dla Hermesa: Własna pamięć z lokalnymi LLM

Samodzielnie hostowany agent AI wymaga czegoś więcej niż długiego okna kontekstu. Potrzebuje sposobu na przechowywanie użytecznych faktów, odzyskiwanie wcześniejszych decyzji oraz rewizję posiadanych informacji w miarę rozwoju projektów.

Hermes Agent jest dostarczany z wbudowanymi plikami pamięci, ale zewnętrzny dostawca może zapewnić znacznie bogatsze możliwości odzyskiwania danych między sesjami. Hindsight jest jedną z ciekawszych opcji w tej dziedzinie. Ten poradnik instaluje go dla Hermes bez chmurowego przetwarzania inferencji, najpierw jako pojedynczy kontener Docker, a następnie na istniejącym serwerze PostgreSQL z osobnymi lokalnymi punktami końcowymi dla modeli.

Poradnik obejmuje wdrożenie, wybór i podłączenie lokalnych modeli osadzania (embedding), ponownego sortowania (reranking) oraz modeli generatywnych, kontrolowanie tego, co auto-retain zapisuje do banku pamięci, łączenie z Hermesem oraz warstwę operacyjną: kopie zapasowe, migracje i codzienna higiena banku pamięci. Przykłady używają świadomego schematu portów — 8080 dla głównego serwera llama.cpp, 8081 dla osadzania, 8082 dla ponownego sortowania, 11434 dla Ollama — więc zmień je na porty, których już używasz, i trzymaj małe serwery z dala od portu głównego modelu.

Czym jest Hindsight

Hindsight to silnik pamięci stałej dla agentów z trzema głównymi operacjami: retain (utrwalanie), recall (przypominanie) i reflect (refleksja/synteza). Retain wyodrębnia i przechowuje informacje; recall łączy wyszukiwanie semantyczne, słowowe, grafowe i czasowe; reflect syntezyzuje odpowiedź z gromadzonych wspomnień. Tło konsolidacji może przekształcać nakładające się obserwacje w bardziej przydatną warstwę wiedzy.

To nie jest tylko baza danych wektorów. Magazyn wektorowy może zlokalizować podobne fragmenty, ale system pamięci musi również zachowywać chronologię, granice projektów, sprzeczne dowody i zmiany w decyzjach. Te tryby awarii są przeanalizowane w artykule o pętlach samowzmacniającej się pamięci.

W szerszym kontekście rynku, zobacz porównanie dostawców pamięci dla agentów). Wbudowane pliki MEMORY.md, USER.md i tryby pamięci Hermes są omówione w artykule o systemie pamięci agenta Hermes.), więc ten artykuł zakłada, że znasz działanie wbudowanej warstwy.

Dlaczego wyjść poza Mnemosyne

Mnemosyne dla Hermes oferuje atrakcyjne pomysły lokalne (local-first), w tym przechowywanie w SQLite i wyszukiwanie hybrydowe. W praktyce ograniczenia instalacyjne, kompatybilność wersji, zachowanie przy zatwierdzaniu zapisów oraz szybkie zmiany wokół wersji przedpreliminarnych 4.0 mogą powodować trudności w przewidywalnej eksploatacji. Są to kwestie operacyjne, a nie dowód na to, że model pamięci Mnemosyne jest fundamentalnie wadliwy.

Hindsight również nie jest wolny od zależności: jego obraz Docker i lokalne modele mogą zużywać znaczną ilość miejsca na dysku. Uruchamianie jego API jako niezależnej usługi, z inferencją gdzie indziej, izoluje aktualizacje i rozwiązywanie problemów od samego agenta.

Wybór wdrożenia

Tutaj “wszystko w jednym” oznacza, że API Hindsight, UI i baza danych znajdują się w jednym kontenerze; model inferencji LLM jest nadal hostowany gdzie indziej. Jest to zamierzone: oficjalny obraz Docker Hindsight nie zawiera gotowego do użycia lokalnego generatywnego serwera llama.cpp.

Używaj adresów dostępnych w LAN, a nie localhost, dla usług uruchamianych na innym hoście. Ogranicz te porty do zaufanych klientów; przykładowe klucze dummy są placeholderami kompatybilności, nie uwierzytelnianiem.

Opcja A: Pojedynczy kontener Hindsight

To najprostszy sposób, aby ocenić Hindsight bez wypełniania maszyny wirtualnej Hermes bibliotekami Python, Torch i zależnościami lokalnych modeli. Kontener uruchamia Hindsight i osadzone PostgreSQL, podczas gdy Twój główny model LLM llama.cpp obsługuje wyodrębnianie i refleksję pamięci.

Tu ważne są dwie etykiety obrazu. ghcr.io/vectorize-io/hindsight:latest to duży obraz — około 9 GB dla AMD64 — ponieważ zawiera osadnik BGE, ponowny sorter MiniLM i osadzone PostgreSQL. latest-slim ma około 500 MB i zakłada, że te dwa modele znajdują się gdzie indziej, co jest tym, czego potrzebujesz, gdy wskażesz Hindsight na konfigurację osadzania i ponownego sortowania z sekcji “Serwowanie i podłączanie lokalnych modeli”. Po tym, jak sprawdzenie stanu zdrowia zakończy się sukcesem, przypnij konkretną etykietę: zmienna etykieta to złe dopasowanie dla bazy danych, którą zamierzasz zachować.

Utwórz katalog i plik Compose na hoście Hindsight:

mkdir -p ~/services/hindsight
cd ~/services/hindsight
cat > compose.yaml <<'YAML'
services:
  hindsight:
    image: ghcr.io/vectorize-io/hindsight:latest
    container_name: hindsight
    restart: unless-stopped
    shm_size: 1gb
    extra_hosts:
      - "host.docker.internal:host-gateway"
    ports:
      - "8888:8888"  # Memory API
      - "9999:9999"  # Control-plane UI
    environment:
      HINDSIGHT_API_WORKER_ID: hindsight-standalone
      HINDSIGHT_API_LLM_PROVIDER: openai
      HINDSIGHT_API_LLM_BASE_URL: http://WORKSTATION_IP:8080/v1
      HINDSIGHT_API_LLM_MODEL: LocalMegaLLM
      HINDSIGHT_API_LLM_API_KEY: dummy
      HINDSIGHT_API_LLM_MAX_CONCURRENT: "2"
    volumes:
      - hindsight-pg0:/home/hindsight/.pg0
volumes:
  hindsight-pg0:
YAML

Zamień WORKSTATION_IP na host uruchamiający llama.cpp. Na systemie Linux, host.docker.internal rozwiązuje się tylko wtedy, gdy kontener deklaruje mapowanie host-gateway pokazane powyżej; bez niego adres bazowy http://host.docker.internal:8080/v1 nie wskazuje na nic. Rezerwacja 1 GB pamięci wspólnej jest szczególnie przydatna dla indeksowania osadzonego PostgreSQL; mała domyślna wartość /dev/shm w Docker może powodować błędy. Zaznaczony wolumen zachowuje bazę danych, gdy kontener jest odtwarzany, a alternatywa w postaci mountu bind musi być własnością uid 1000, użytkownika wewnątrz obrazu.

HINDSIGHT_API_WORKER_ID powinien pozostać stabilny podczas odtwarzania — domyślna wartość Docker to nazwa hosta kontenera, a zadanie, które było w trakcie, gdy kontener padł, pozostaje zablokowane pod starą identyfikacją pracownika.

docker compose up -d
docker compose logs -f --tail=100
curl -f http://localhost:8888/health

Jeśli zainstalowana wersja Hindsight wystawia stan zdrowia pod inną ścieżką, zbadaj http://localhost:8888/docs i logi kontenera. Warstwa kontrolna jest normalnie dostępna pod http://HINDSIGHT_HOST:9999. Gdy podstawowe wdrożenie działa, możesz również skierować jego dostawców osadzania i ponownego sortowania na konfigurację z sekcji “Serwowanie i podłączanie lokalnych modeli”, zamiast ładować domyślne modele wewnątrz kontenera.

Nie wystawiaj portów 8888 lub 9999 bezpośrednio do Internetu. Używaj sieci prywatnej lub uwierzytelnionego proxy odwróconego. Osadzone PostgreSQL jest wygodne do testów, ale zewnętrznie zarządzana baza danych jest łatwiejsza w tworzeniu kopii zapasowych i utrzymaniu.

Opcja B: Hindsight przeciwko istniejącemu serwerowi PostgreSQL

Długotrwałą instalację preferuję utrzymując API Hindsight, bazę danych i punkty końcowe inferencji osobno. Maszyna wirtualna Hindsight może pozostać mała, ponieważ uruchamia orkiestrację i usługi HTTP, a nie ciężkie modele.

Przygotowanie PostgreSQL i pgvector

Hindsight wymaga PostgreSQL 14 lub nowszego i rozszerzenia wektorowego w bazie danych hindsight. Rozszerzenie jest przypisane do bazy danych: zainstalowanie pakietu na serwerze nie robi nic, dopóki nie uruchomi się CREATE EXTENSION. Na serwerze PostgreSQL z Debiانا lub Ubuntu, zainstaluj pakiet pgvector pasujący do rzeczywistej dużej wersji PostgreSQL; na przykład dla PostgreSQL 16:

sudo apt update
sudo apt install postgresql-16-pgvector

Nazwa pakietu i jego dostępność zależą od skonfigurowanych repozytoriów apt. Jeśli jest niedostępny, postępuj zgodnie z instrukcjami instalacji pgvector lub zainstaluj kompatybilny pakiet z repozytorium PGDG PostgreSQL. Nie zmieniaj ślepo dużej wersji PostgreSQL na wspólnym serwerze.

Utwórz dedykowaną rolę i bazę danych jako administrator PostgreSQL:

CREATE ROLE hindsight LOGIN PASSWORD 'REPLACE_WITH_LONG_PASSWORD';
CREATE DATABASE hindsight OWNER hindsight;

Połącz się z nową bazą danych i włącz rozszerzenie:

sudo -u postgres psql -d hindsight -c \
  'CREATE EXTENSION IF NOT EXISTS vector;'
sudo -u postgres psql -d hindsight -c \
  "SELECT extname, extversion FROM pg_extension WHERE extname = 'vector';"

Rozszerzenie normalnie potrzebuje podwyższonych przywilejów do instalacji; rola aplikacji nie musi być superużytkownikiem. Hindsight używa domyślnie pgvector i chce wersji 0.8.0 lub nowszej dla iteracyjnych skanów ANN; starsze serwery odrzucają tę ustawienie. HINDSIGHT_API_VECTOR_EXTENSION może zamiast tego wybrać pgvectorscale (opcję DiskANN, którą Hindsight dokumentuje dla bardzo dużych banków) lub vchord, oba z których wymagają dodatkowego pakietowania dla tej konkretnej kompilacji PostgreSQL. Przełączanie algorytmów po istnieniu wspomnień zatrzymuje start i wymaga migracji, więc wybierz przed pierwszym retain. Dla osobistego banku Hermes, pgvector to ten do zainstalowania i potem już zostawienia.

Pozwalaj tylko hoście Hindsight przez pg_hba.conf, na przykład:

host  hindsight  hindsight  192.168.1.50/32  scram-sha-256

Ustaw listen_addresses PostgreSQL odpowiednio i używaj TLS lub zaufanej sieci prywatnej dla połączeń między hostami. Twórz kopie zapasowe tej bazy danych niezależnie od kontenera Docker Hindsight. Jeśli serwer jest współdzielony z innymi aplikacjami, trzymaj Hindsight w osobnej bazie danych lub ustaw HINDSIGHT_API_DATABASE_SCHEMA na schemat, który posiadasz; domyślnym schematem jest public.

Uruchamianie Hindsight przeciwko PostgreSQL

Utwórz compose.yaml na maszynie wirtualnej Hindsight. Ta wersja celowo nie uruchamia PostgreSQL lokalnie:

services:
  hindsight:
    image: ghcr.io/vectorize-io/hindsight:latest-slim
    restart: unless-stopped
    ports:
      - "8888:8888"
      - "9999:9999"
    env_file: .env
    environment:
      HINDSIGHT_API_LLM_PROVIDER: openai
      HINDSIGHT_API_LLM_BASE_URL: http://WORKSTATION_IP:8080/v1
      HINDSIGHT_API_LLM_MODEL: LocalMegaLLM
      HINDSIGHT_API_LLM_API_KEY: dummy
      HINDSIGHT_API_LLM_MAX_CONCURRENT: "2"
      HINDSIGHT_API_DB_POOL_MIN_SIZE: "2"
      HINDSIGHT_API_DB_POOL_MAX_SIZE: "10"
      HINDSIGHT_API_WORKER_ID: hindsight-standalone

Przechowuj zewnętrzny adres URL bazy danych w pliku o nazwie .env:

HINDSIGHT_API_DATABASE_URL=postgresql://hindsight:YOUR_PASSWORD@POSTGRES_IP:5432/hindsight

chmod 600 .env
docker compose up -d
docker compose logs -f --tail=100

Jeśli Twoje hasło zawiera @, :, / lub inne zarezerwowane znaki URL, zakoduj je URL przed umieszczeniem w ciągu połączenia. Przetestuj, czy maszyna wirtualna Hindsight może osiągnąć port 5432 PostgreSQL, i czy pg_hba.conf pozwala hoście Hindsight — serwer związany tylko z 127.0.0.1 odrzuca połączenie nawet wtedy, gdy URL wygląda poprawnie. Pozwól pierwszemu uruchomieniu na wykonanie migracji bazy danych; migracje wykonują się przy uruchomieniu, chyba że ustawisz HINDSIGHT_API_RUN_MIGRATIONS_ON_STARTUP=false. Gdy API i baza danych są uruchomione, kontynuuj z Wybór modeli dla Hindsight i Serwowanie i podłączanie lokalnych modeli przed połączeniem z Hermesem.

Wybór modeli dla Hindsight

Wdrożenie stawia API i bazę danych w sieci. Następna decyzja to, które modele wypełnią trzy role inferencji: osadzanie (embeddings) dla kandydatów do przypomnienia, ponowny sorter (reranker) do ich ponownego sortowania oraz generatywny model LLM dla retain, reflect i konsolidacji. Praktycznym domyślnym wyborem dla hosta Hindsight z CPU, którego GPU jest już zajęte rozmową, jest Qwen/Qwen3-Embedding-0.6B w procesie, BAAI/bge-reranker-v2-m3 w procesie i współdzielony model czata llama.cpp dla pracy generatywnej.

Modele osadzania

Hindsight odczytuje wymiar osadzania przy starcie i rozmiaruje bank pamięci tak, aby pasował, więc model, który wybierzesz przy pierwszym retain, to model, który bank będzie trzymał, aż go odbudujesz. Wymiarowość i zachowanie instrukcji mają większe znaczenie niż miejsce na liście rankingowej: silniejszy osadnik 8B nie jest warty migracji, jeśli bank jest już o wymiarze 384 lub 1024. Wiersze poniżej są posortowane od najlżejszego do najcięższego; wartości RAM to przybliżony rozmiar załadowany na CPU (FP16 / typowe lokalne ładowanie), a nie rozmiar pliku GGUF.

Sposób uruchamiania modelu to druga połowa wyboru. Dostawcy osadzania Hindsight, od najprostszych po najbardziej skomplikowane:

Qwen3-Embedding-0.6B nie wymaga zewnętrznego serwisu osadzania. Na hoście Hindsight z CPU ładuje się w procesie API z dostawcą local — Hugging Face pobiera wagi przy pierwszym starcie, a dostawca sam stosuje instrukcję wyszukiwania modelu:

# Compose environment (or equivalent .env keys)
HINDSIGHT_API_EMBEDDINGS_PROVIDER: local
HINDSIGHT_API_EMBEDDINGS_LOCAL_MODEL: Qwen/Qwen3-Embedding-0.6B

Używaj zewnętrznego endpointu zgodnego z OpenAI tylko wtedy, gdy chcesz umieścić osadnik na innej maszynie lub poza procesem API. Ollama jest jednym z takich hostów:

# Embeddings: Qwen3-Embedding-0.6B on Ollama
HINDSIGHT_API_EMBEDDINGS_PROVIDER: openai
HINDSIGHT_API_EMBEDDINGS_OPENAI_BASE_URL: http://192.168.1.123:11434/v1
HINDSIGHT_API_EMBEDDINGS_OPENAI_MODEL: qwen3-embedding:0.6b-q8_0
HINDSIGHT_API_EMBEDDINGS_OPENAI_API_KEY: dummy

Zamień host, port i tag na to, co pokazuje ollama list na Twojej maszynie inferencji.

HINDSIGHT_API_EMBEDDINGS_QUERY_PREFIX zależy od dostawcy:

Dla ścieżki zewnętrznej ustaw:

# Real newline before Query:. Bash $'...' is the reliable way to pass it.
HINDSIGHT_API_EMBEDDINGS_QUERY_PREFIX=$'Instruct: Given a web search query, retrieve relevant passages that answer the query\nQuery:'
HINDSIGHT_API_EMBEDDINGS_PASSAGE_PREFIX=

W pliku Compose YAML ten sam ciąg wymaga jawnej \n (lub dosłotnej wartości wieloliniowej). Ustaw prefiksy przed pierwszym retain: zmiana ich później oznacza, że stare wektory i nowe zapytania nie będą już w tej samej przestrzeni.

Dwie właściwości decydują bardziej niż pozycja na liście rankingowej. Czułość na instrukcje: osadzanie Qwen3 stosuje instrukcję wyszukiwania po stronie zapytania; bez odpowiadającego prefiksu na serwerze zgodnym z OpenAI, strona przechowywana i strona zapytania przestają być w tej samej przestrzeni. Blokada wymiaru: ponieważ szerokość jest odczytywana raz przy starcie, przejście z 0.6B na 4B później to migracja banku, a nie zmiana konfiguracji — a nawet wymiana o tym samym wymiarze (BGE-M3 ↔ Qwen3-0.6B, lub EmbeddingGemma 2 ↔ nomic przy 768) zmienia przestrzeń wektorową, więc wektory banku nie są przeliczane automatycznie. Zaplanuj nowy bank lub ręczne przeosadzanie/przeindeksowanie; zobacz Eksport, import i migracja banku pamięci. Po opuszczeniu BGE-small, przetestuj recall_min_scores pod kątem nowego rozkładu ocen — progi skalibrowane na BGE-small mogą być zbyt ciasne dla Qwen3-0.6B i głodować ponowny sorter z kandydatów. Dla benchmarków i tła GGUF/Ollama dla rodziny Qwen3, zobacz Modele Qwen3 Embedding i Reranker na Ollama.

Modele ponownego sortowania

Osadzanie przywołuje zestaw kandydatów; ponowny sorter ocenia każdą parę zapytanie/fragment i sortuje go ponownie, zanim Hindsight go wstrzyknie. Z dostawcą local, Hindsight ładuje cross-encoder SentenceTransformers (lub generatywny ponowny sorter tam, gdzie to wspierane). Ze zewnętrznym endpointem zgodnym z Cohere, wysyła pełne ciało w stylu Cohere do HINDSIGHT_API_RERANKER_COHERE_BASE_URL. Ponowny sorter jest opcjonalny, ale gdy osadnik jest ustalony, jest zwykle największym dźwignią jakości przypomnienia — a na CPU często większość czasu rzeczywistego przypomnienia. Wiersze są posortowane od najlżejszego do najcięższego.

Chmurowe API ponownych sorterów (Cohere, ZeroEntropy, Alibaba qwen3-rerank, TypeSafe i podobne) działają w Hindsight, ale wysyłają tekst pamięci poza maszynę. Dla lokalnego, wielodomenowego układu są poza zakresem.

Dwa operacyjne ograniczenia dominują wybór. VRAM: jeśli model rozmowy już nasyca GPU (na przykład Qwen3.8-27B Q5 na karcie 16 GB bez zapasu), każdy wiersz “Preferowany GPU” jest poza stołem, a żywy wybór sprowadza się do MiniLM lub BGE-v2-m3 na CPU. Liczba kandydatów: HINDSIGHT_API_RERANKER_MAX_CANDIDATES (30 w przykładzie zewnętrznego endpointu poniżej) ogranicza, ile fragmentów model re-ocenia; każdy kandydat to pełne przejście przodowe, więc obniż dolny limit, zanim przejdziesz do wyższego poziomu modelu. Dla Qwen3 przez llama.cpp, GGUF musi zachować głowę rankingu — stary convert_hf_to_gguf.py, który ją usuwa, ocenia każdy fragment blisko zera — a nawet poprawna konwersja nadal potrzebuje testu znany dobry/znany zły fragment, aż do potwierdzenia ścieżki generatywnego oceniania.

Poziomy generatywnego LLM

Modele osadzania i ponownego sortowania nie są substytutami generatywnego LLM używanego do wyodrębniania i rozumowania nad pamięciami. Hindsight wspiera domyślny LLM i nadpisywania specyficzne dla operacji, które mogą celować w ten sam serwer llama.cpp lub niezależne punkty końcowe.

To są zalecenia operacyjne, a nie oficjalne minimalne liczby parametrów Hindsight. Mały model może poprawnie wyodrębnić numer portu, ale przeoczyć, że wcześniejsza decyzja architektoniczna została wyparta. Wiarygodność wyjściu strukturalnego i wierna obsługa negacji ważą więcej niż sama nominalna liczba parametrów. Własne domyślne temperatury Hindsight warto zostawić w spokoju — 0.1 dla retain, 0.0 dla konsolidacji, 0.9 dla reflect — a dla retain i konsolidacji, alias nietrywialny jest wart serwowania, jeśli Twoja kompilacja llama.cpp go ma, ponieważ małe checkpointy Qwen3.5 spendują wiele tokenów w trybie myślenia.

Dla wdrożenia z istniejącym endpointem llama.cpp Qwen3.8-27B, zacznij od współdzielenia go między generatywnymi zadaniami Hindsight z niską współbieżnością:

HINDSIGHT_API_LLM_PROVIDER=openai
HINDSIGHT_API_LLM_BASE_URL=http://WORKSTATION_IP:8080/v1
HINDSIGHT_API_LLM_MODEL=LocalMegaLLM
HINDSIGHT_API_LLM_API_KEY=dummy
HINDSIGHT_API_LLM_MAX_CONCURRENT=2
HINDSIGHT_API_RETAIN_LLM_MAX_CONCURRENT=1
HINDSIGHT_API_CONSOLIDATION_LLM_MAX_CONCURRENT=1

Później, kieruj rutynowe wyodrębnianie do niezależnego modelu 9B i zarezerwuj 27B dla trudnej refleksji:

HINDSIGHT_API_RETAIN_LLM_PROVIDER=openai
HINDSIGHT_API_RETAIN_LLM_BASE_URL=http://MEMORY_LLM_HOST:8083/v1
HINDSIGHT_API_RETAIN_LLM_MODEL=MemoryLLM
HINDSIGHT_API_RETAIN_LLM_API_KEY=dummy

HINDSIGHT_API_REFLECT_LLM_PROVIDER=openai
HINDSIGHT_API_REFLECT_LLM_BASE_URL=http://WORKSTATION_IP:8080/v1
HINDSIGHT_API_REFLECT_LLM_MODEL=LocalMegaLLM
HINDSIGHT_API_REFLECT_LLM_API_KEY=dummy

Mniejszy model 4B jest ekonomiczny, ale potrzebuje testów; 9B jest rozsądnym kompromisem jakość/wydajność. Jeśli retain i konsolidacja dzielą mały model, obniż HINDSIGHT_API_CONSOLIDATION_LLM_BATCH_SIZE do 2 — domyślna partia 8 to długi prompt dla małego okna kontekstu. Qwen3.6-35B-A3B jest atrakcyjny dla osobnego, dobrze wyposażonego serwera inferencji (to model mixture-of-experts z około 3 miliardami aktywnych parametrów, więc traktuj go jako mały aktywny model), podczas gdy gęsty model 27B jest zwykle niepotrzebny dla każdego rutynowego zdarzenia retain. Ograniczanie tła współbieżności chroni model rozmowy Hermes przed wyskokami konserwacji pamięci.

Serwowanie i podłączanie lokalnych modeli

Jeśli ustawienia w-procesowe local osadzania i ponownego sortownika z sekcji “Wybór modeli” są wystarczające, możesz pominąć podsekcje zewnętrznego Ollama i llama.cpp i przejść do podłączania — lub zostawić Compose na domyślnych local tam pokazanych. Zewnętrzne punkty końcowe mają znaczenie, gdy osadnik lub ponowny sorter powinien znajdować się na innym hoście.

Zewnętrzne osadzanie: Ollama lub llama.cpp

Zewnętrzne osadzanie jest dla sytuacji, gdy chcesz Qwen3-Embedding-0.6B (lub inny model) na osobnym hoście. Dwie praktyczne opcje to Ollama, który obsługuje pozyskiwanie i serwowanie modeli z małą konfiguracją, oraz llama.cpp, który daje precyzyjną kontrolę nad kwantyzacją GGUF, wątkami CPU, umieszczeniem urządzeń i partiami. Tło i benchmarki dla obu modeli Qwen3 są w Modele Qwen3 Embedding i Reranker na Ollama.

Qwen3-Embedding-0.6B zwraca 1024-wymiarowe wektory, a Hindsight odczytuje tę szerokość przy starcie i rozmiaruje bazę danych tak, aby pasowała. Bank tworzony z dostarczonym 384-wymiarowym modelem BGE nie może przyjąć tego modelu — zacznij od pustej bazy danych lub wolumenu i zdecyduj o modelu osadzania przed pierwszym retain. Późniejsza zmiana dostawcy osadzania wymaga przeosadzania przechowywanych rekordów, nawet jeśli oba modele używają tego samego wymiaru.

Opcja 1: Ollama dla Qwen3-Embedding-0.6B

Zainstaluj Ollama na hoście inferencji używając jego oficjalnej dokumentacji instalacji Linux, a następnie uruchom model osadzania:

ollama pull qwen3-embedding:0.6b
ollama serve

Dla dostępu zdalnego, skonfiguruj OLLAMA_HOST=0.0.0.0:11434 Ollama w środowisku usługi, zrestartuj usługę i zabezpiecz ją firewall’iem do maszyny wirtualnej Hindsight — procedura jest opisana w Zdalny dostęp do Ollama. Daemon związany tylko z 127.0.0.1 jest niewidoczny dla kontenera Hindsight. Najpierw sprawdź nazwę modelu z ollama list i przetestuj standardowy endpoint osadzania:

curl http://EMBED_HOST:11434/api/embed \
  -H 'Content-Type: application/json' \
  -d '{"model":"qwen3-embedding:0.6b","input":"A test memory"}'

Dostawca osadzania OpenAI Hindsight zamiast tego woła endpoint /v1/embeddings zgodny z OpenAI w Ollama. Zweryfikuj, że ten endpoint działa z Twoją wersją Ollama przed skonfigurowaniem Hindsight. Ollama jest prosty dla osadzania; nie zakładaj, że jego API oferuje kompatybilny endpoint ponownego sortowania. Dla ponownego sortowania preferuj ścieżkę local BGE poniżej lub osobny endpoint llama.cpp / TEI po zweryfikowaniu ocen.

Opcja 2: llama.cpp dla Qwen3-Embedding-0.6B

Pobierz zweryfikowaną konwersję GGUF Qwen3-Embedding-0.6B. Użyj nazwy pliku GGUF, który faktycznie pobrałeś:

#!/bin/sh
# start-embedding.sh - CPU-only embedding server
set -eu
cd "$HOME/prj"
exec ./llama.cpp/llama-server \
  --host 0.0.0.0 --port 8081 \
  --model "$HOME/ggufs/Qwen3-Embedding-0.6B-Q8_0.gguf" \
  --alias qwen3-embedding-0.6b \
  --embedding --pooling last \
  --ctx-size 4096 --parallel 1 \
  --threads 4 --threads-batch 4 \
  --batch-size 512 --ubatch-size 256 \
  --n-gpu-layers 0

Osadzanie Qwen3 używa poolingu ostatniego tokena, w przeciwieństwie do poolingu CLS używanego przez niektóre modele BGE. Kompilacja llama.cpp tylko z CPU jest preferowana, jeśli chcesz absolutnie żadnej inicjalizacji CUDA na stacji roboczej, której GPU jest zajęte przez duży model rozmowy. Nie włączaj --reranking na tym serwerze osadzania: to połączenie to znany sposób na uzyskanie wektora zer.

curl -s http://EMBED_HOST:8081/v1/embeddings \
  -H 'Content-Type: application/json' \
  -d '{"model":"qwen3-embedding-0.6b","input":"A test memory"}' \
  | jq '.data[0].embedding | length'

Pełnowymiarowe wyjście Qwen3-Embedding-0.6B powinno zawierać 1024 floatów. Sprawdź, czy konwersja GGUF i obsługa instrukcji zapytania/dokumentu Hindsight są kompatybilne; modele osadzania wrażliwe na instrukcje mogą tracić dokładność, gdy są błędnie promptowane.

Ponowny sorter: lokalny BGE lub Qwen3 przez llama.cpp

Ponowne sortowanie różni się od osadzania: model ocenia każdą parę zapytanie/dokument i zwraca ocenę trafności. Na hoście Hindsight tylko z CPU — lub zawsze, gdy GPU do rozmów nie ma zapasu VRAM — praktyczną ścieżką jest dostawca local Hindsight z BAAI/bge-reranker-v2-m3 (lub lżejszym domyślnym MiniLM). Nie jest wymagany sidecar:

HINDSIGHT_API_RERANKER_PROVIDER=local
HINDSIGHT_API_RERANKER_LOCAL_MODEL=BAAI/bge-reranker-v2-m3
HINDSIGHT_API_RERANKER_MAX_CANDIDATES=20

Qwen3-Reranker-0.6B to generatywny sorter tokena “yes”, a nie klasyczny cross-encoder. Może być serwowany przez llama.cpp z konwersją GGUF zaprojektowaną do rankingu, ale traktuj tę ścieżkę jako eksperymentalną, dopóki nie potwierdzisz ocen na parze znany dobry/znany zły: stary convert_hf_to_gguf.py, który usuwa głowę rankingu, ocenia każdy fragment blisko zera, a natywna ścieżka /rerank llama.cpp ma znane raporty błędnych ocen dla tej rodziny.

#!/bin/sh
# start-reranker.sh - GPU or CPU as selected by --n-gpu-layers
set -eu
cd "$HOME/prj"
exec ./llama.cpp/llama-server \
  --host 0.0.0.0 --port 8082 \
  --model "$HOME/ggufs/Qwen3-Reranker-0.6B-Q8_0.gguf" \
  --alias qwen3-reranker-0.6b \
  --embedding --reranking --pooling rank \
  --ctx-size 4096 --parallel 1 \
  --batch-size 512 --ubatch-size 256 \
  --n-gpu-layers 99

Ustaw --n-gpu-layers 0, aby uruchomić go na CPU. Wersja GPU potrzebuje dodatkowej VRAM na bufora obliczeniowe i kontekst, nie tylko na wagi modelu; unikaj zakładania, że rozmiar pliku to całkowita alokacja GPU.

curl -s http://RERANK_HOST:8082/v1/rerank \
  -H 'Content-Type: application/json' \
  -d '{"model":"qwen3-reranker-0.6b", "query":"PostgreSQL storage", "documents":["Hindsight stores memories in PostgreSQL.","A recipe for bread."], "top_n":2}' \
  | jq

Dokument PostgreSQL powinien zostać wyżej niż nierelatywny dokument; wszystkie zerowe oceny trafności oznaczają, że GGUF to zła konwersja, a przypomnienie będzie wyglądać losowo, nawet gdy fakty są przechowywane. Sprawdź dokładny kształt results[].index i results[].relevance_score: Hindsight oczekuje odpowiedzi ponownego sortowania zgodnej z Cohere, a kompatybilność llama.cpp może się różnić między kompilacjami.

Podłącz punkty końcowe do Hindsight

Dodaj następujące ustawienia środowiskowe do usługi Compose Hindsight lub przechowaj je w jego pliku .env. Wybierz jedną ścieżkę osadzania — w-procesowe local, Ollama lub llama.cpp — nigdy dwie naraz.

# Option A: in-process Qwen3 on the Hindsight host (CPU; no sidecar)
HINDSIGHT_API_EMBEDDINGS_PROVIDER=local
HINDSIGHT_API_EMBEDDINGS_LOCAL_MODEL=Qwen/Qwen3-Embedding-0.6B

# Option B: llama.cpp embedding service
# HINDSIGHT_API_EMBEDDINGS_PROVIDER=openai
# HINDSIGHT_API_EMBEDDINGS_OPENAI_BASE_URL=http://EMBED_HOST:8081/v1
# HINDSIGHT_API_EMBEDDINGS_OPENAI_MODEL=qwen3-embedding-0.6b
# HINDSIGHT_API_EMBEDDINGS_OPENAI_API_KEY=dummy
# HINDSIGHT_API_EMBEDDINGS_OPENAI_BATCH_SIZE=8
# HINDSIGHT_API_EMBEDDINGS_QUERY_PREFIX=$'Instruct: Given a web search query, retrieve relevant passages that answer the query\nQuery:'
# HINDSIGHT_API_EMBEDDINGS_PASSAGE_PREFIX=

# Option C: Ollama on another host
# HINDSIGHT_API_EMBEDDINGS_PROVIDER=openai
# HINDSIGHT_API_EMBEDDINGS_OPENAI_BASE_URL=http://192.168.1.40:11434/v1
# HINDSIGHT_API_EMBEDDINGS_OPENAI_MODEL=qwen3-embedding:0.6b-q8_0
# HINDSIGHT_API_EMBEDDINGS_OPENAI_API_KEY=dummy
# HINDSIGHT_API_EMBEDDINGS_QUERY_PREFIX=$'Instruct: Given a web search query, retrieve relevant passages that answer the query\nQuery:'
# HINDSIGHT_API_EMBEDDINGS_PASSAGE_PREFIX=

# Option: local BGE reranker (no sidecar; preferred on CPU)
HINDSIGHT_API_RERANKER_PROVIDER=local
HINDSIGHT_API_RERANKER_LOCAL_MODEL=BAAI/bge-reranker-v2-m3
HINDSIGHT_API_RERANKER_MAX_CANDIDATES=20

# Option: llama.cpp Cohere-compatible rerank endpoint (validate Qwen3 scores first)
# HINDSIGHT_API_RERANKER_PROVIDER=cohere
# HINDSIGHT_API_RERANKER_COHERE_BASE_URL=http://RERANK_HOST:8082/v1/rerank
# HINDSIGHT_API_RERANKER_COHERE_MODEL=qwen3-reranker-0.6b
# HINDSIGHT_API_RERANKER_COHERE_API_KEY=dummy
# HINDSIGHT_API_RERANKER_MAX_CANDIDATES=30

Nazwy zmiennych są specyficzne dla dostawcy, a nieudany strzał jest cichy: HINDSIGHT_API_EMBEDDINGS_BASE_URL to zły klucz, a Hindsight cicho celuje w własny endpoint osadzania OpenAI, a nie w Twój lokalny serwer. Użyj HINDSIGHT_API_EMBEDDINGS_OPENAI_BASE_URL. Z ścieżką ponownego sortownika zgodną z Cohere, Hindsight wysyła pełne ciało w stylu Cohere do HINDSIGHT_API_RERANKER_COHERE_BASE_URL; jeśli log kontenera pokazuje 404 dla /v1/rerank/rerank, Twoja kompilacja dodaje /rerank samodzielnie i wartość powinna się kończyć na /v1.

Dla opcji B i C, użyj wartości HINDSIGHT_API_EMBEDDINGS_QUERY_PREFIX z Modele osadzania (Opcja A pozostawia go nieustawione). Przetestuj wyszukiwanie zapytanie-do-fragmentu na Twoich rzeczywistych pamięciach po pierwszym retain.

Kontrola tego, co zostaje zapamiętane

Gdy stos działa, następnym trybem awarii jest zwykle ścieżka zapisu: Hermes domyślnie ustawia auto_retain: true, więc każda tura rozmowy może być wyodrębniona do banku. Błędne zgadywania, odrzucone plany i eksploracyjne stwierdzenia stają się przeszukiwalnymi faktami, a późniejsze przypomnienie traktuje je jako dowody — pętla opisana w pętlach samowzmacniającej się pamięci. Polityka przechwytywania dla Hindsight wśród innych dostawców jest podsumowana w porównaniu dostawców pamięci dla agentów).

Tryby przechwytywania dostępne dziś

Ustawienie auto_retain na false dezaktywuje automatyczne przechowywanie. Nie dodaje okna zatwierdzania ludzkiego przed każdym zapisem. Agent nadal może wywołać hindsight_retain, gdy tylko jego narzędzia pozwalają; traktuj jawne retain jako świadome przechwytywanie, a nie oczekującą kolejkę.

Luka kolejki zatwierdzania

Częstym życzeniem jest oczekująca kolejka kandydatów pamięci, którą przeglądasz i zatwierdzasz, zanim wejdą do banku. Hindsight pod Hermes nie zapewnia dziś tego kontraktu. Mnemosyne dla Hermes implementuje stopniowe zapisy specyficzne dla dostawcy w niektórych wersjach; ta ścieżka nie jest wspólnym standardem Hermes i nie dotyczy wtyczki Hindsight. Dopóki nie będzie istniał górny przepływ zatwierdzenia, wykonalnym wzorcem jest auto_retain: false, świadome hindsight_retain i inspekcja lub usuwanie w UI warstwy kontrolnej Hindsight przed kolejną sesją polegającą na złym fakcie. Nie ma brakującego klucza write_approval dla Hindsight, który można by szukać w config.json.

Sterowanie bankiem (misje, etykiety, dyrektywy, modele mentalne)

Ludzie często nazywają następną warstwę “dostrojeniem” (finetuning). W Hindsight jest to głównie konfiguracja banku, a nie tylko config.json Hermes: misje i ustawienia wyodrębniania sterują tym, co retain zachowuje; etykiety strukturyzują encje; dyrektywy i modele mentalne kształtują późniejszą syntezę.

Misje, zwięzłe wyodrębnianie i etykiety zmniejszają szum i poprawiają wyszukiwanie. Nie zastępują wyłączenia auto-retain, gdy dokładność jest ważniejsza niż kompletność. Preferuj krótką misję retain nazywającą trwałe decyzje projektowe i ignorującą logistykę czata; dodawaj etykiety encji tylko, gdy masz realną taksonomię; dodawaj modele mentalne dla dwóch lub trzech powtarzających się pytań, po tym, jak bank już trzyma czyste fakty.

Zalecany profil higieny

Konkretny punkt startowy dla osobistego banku Hermes:

{
  "mode": "local_external",
  "api_url": "http://HINDSIGHT_VM_IP:8888",
  "bank_id": "hermes",
  "memory_mode": "hybrid",
  "auto_recall": true,
  "recall_sync": false,
  "auto_retain": false,
  "retain_async": true,
  "recall_prefetch_method": "recall"
}

Na banku ustaw misję retain i zostaw wyodrębnianie w trybie concise (przez warstwę kontrolną lub API Banków). Po jawnym retain, otwórz UI, potwierdź obserwację i usuń błędy przed uruchomieniem konsolidacji lub odświeżenia modelu mentalnego. Zostaw recall_prefetch_method na recall — reflect spenduje wywołanie modelu czata przed każdą turą i wstrzykuje syntezę, a nie podstawowe fakty.

Połączenie agenta Hermes z Hindsight

Na maszynie wirtualnej Hermes, zainstaluj wtyczkę katalogową, a następnie uruchom kreatora konfiguracji. Wybierz Hindsight i tryb local_external; wtyczka nie potrzebuje uruchamiać osadzonego PostgreSQL ani uruchamiać stosu modeli Hindsight lokalnie, a local_embedded uruchomiłoby drugi demon Hindsight obok kontenera, który właśnie uruchomiłeś.

hermes plugins install hindsight
hermes memory setup hindsight

Będzie ciekawy zestaw opcji roli agenta używającej hindsight

hermes memory status

Zewnętrzne połączenie Hindsight znajduje się w ~/.hermes/hindsight/config.json. Ilustracyjna konfiguracja zachowująca ciągłe przechwytywanie (domyślne Hermes) to:

{
  "mode": "local_external",
  "api_url": "http://HINDSIGHT_VM_IP:8888",
  "bank_id": "hermes",
  "memory_mode": "hybrid",
  "auto_recall": true,
  "recall_sync": false,
  "auto_retain": true,
  "retain_async": true,
  "retain_every_n_turns": 1
}

Dla jawnego tylko retain i sterowania bankiem, użyj profilu higieny z Kontrola tego, co zostaje zapamiętane zamiast zostawiania auto_retain włączonego. recall_sync: false priorytetyzuje interaktywną responsywność, ale może wstrzykiwać odzyskany kontekst w następnej turze. Używaj synchronicznego recall, gdy bieżące żądanie musi uwzględnić najnowsze pamięci, zanim model zacznie odpowiadać. retain_async: true unika blokowania zwykłych odpowiedzi, podczas gdy pamięci są przetwarzane.

Domyślne przypomnienie wtyczki to tylko obserwacje; surowe fakty światowe i doświadczeniowe pozostają w banku i poza promptem, dopóki konsolidacja nie zapisze obserwacji, lub dopóki nie poszerzysz recall_types do observation,world,experience. Poszerzenie go na pierwszy tydzień i obserwowanie warstwy kontrolnej, a następnie zawężanie, jest rozsądną kolejnością.

Wbudowana pamięć Hermes pozostaje aktywna obok dostawcy; zachowanie MEMORY.md i USER.md podczas uczenia się, co Hindsight dodaje, jest w porządku, a artykuł o systemie pamięci to miejsce, aby zdecydować, czy pliki płaskie powinny pozostać.

Zrestartuj bramkę, jeśli już działa:

hermes gateway restart
hermes memory status

Status powinien identyfikować Hindsight jako aktywnego dostawcę. Dla szerszej referencji poleceń, w tym TUI Hermes i poleceń wtyczek, zobacz ściągawkę CLI agenta Hermes.

Walidacja pamięci, a nie tylko instalacji

Poproś Hermes, aby zapamiętał jednorazowy fakt o projekcie testowym, rozpocznij inną sesję i poproś o ten fakt ponownie. Utrwalanie jest asynchroniczne domyślnie, a wyodrębnianie czeka na model czata, więc daj głównemu serwerowi llama.cpp chwilę przed ocenianiem. Następnie przetestuj trudniejszy przypadek: powiedz Hermesowi, że wcześniejsza decyzja się zmieniła, i zapytaj, która decyzja jest bieżąca i dlaczego. Sprawdź UI Hindsight i przechowywane obserwacje, zamiast zakładać, że memory status dowodzi, że ingest i recall są poprawne.

Jeśli odpowiedź wraca pusta, zbadaj warstwę kontrolną przed zmianą modeli. Retain może się udać i nadal być niewidoczny dla recall, gdy recall_types to tylko obserwacje i konsolidacja się nie uruchomiła — poszerzenie recall_types to pierwsza kontrola. Odmowa połączenia w logu serwera osadzania oznacza, że kontener nie może osiągnąć portu osadzania, a wszystkie zerowe oceny ponownego sortownika oznaczają, że GGUF to zła konwersja.

Wybory ścieżki zapisu (auto_retain, misje, luka zatwierdzania) są omówione w Kontrola tego, co zostaje zapamiętane.

Rozwiązywanie problemów i uwagi operacyjne

Praktyczna mała instalacja to 2-4 vCPU i 4-6 GB RAM dla VM Hindsight API gdy PostgreSQL i cała inferencja są zewnętrzne. Alokacja dysku nadal zależy od wybranego obrazu Docker i przechowywanych warstw obrazu; alokuj około 30-40 GB początkowo z zapasem na rozszerzenie. Rozmiaruj hosta PostgreSQL na podstawie rzeczywistego wolumenu pamięci, wydajności przechowywania i innych baz danych, które serwuje.

Kopie zapasowe i przywracanie banku Hindsight

Bank pamięci to jedyny stan, który ma znaczenie, i znajduje się w PostgreSQL. W Opcji B to jest baza danych, którą zarządzasz; w Opcji A to jest osadzony wolumen nazwany pg0 wewnątrz kontenera. Rób kopie zapasowe niezależnie od kontenera Hindsight — odtworzenie kontenera bez najpierw przechwycenia wolumenu lub bazy danych odrzuca bank, a hermes backup nie sięga do banku działającego w osobnej usłudze.

Opcja B — zewnętrzny PostgreSQL. Zrób zrzut bazy danych hindsight w formacie custom, a następnie przywróć go do bazy roboczej, aby zweryfikować archiwum, zanim mu ufasz:

pg_dump -h POSTGRES_IP -U hindsight -Fc hindsight > hindsight-bank.dump

# restore into a scratch database to prove the dump is usable
createdb -h POSTGRES_IP -U postgres hindsight-verify
pg_restore -h POSTGRES_IP -U postgres -d hindsight-verify hindsight-bank.dump

Potwierdź rozszerzenie pgvector i próbkowe przypomnienie w przywróconej kopii, zanim usuniesz docelowy zrzut oryginału. Zachowuj zrzut na innym hoście niż VM Hindsight i wykonuj to jako administrator PostgreSQL (rola, która może tworzyć bazy danych), a nie rola aplikacji.

Opcja A — pojedynczy kontener. Osadzona baza danych to wolumen nazwany, więc zatrzymaj kontener i spakuj wolumen przez jednorazowy obraz:

docker stop hindsight
docker run --rm -v hindsight-pg0:/data -v "$PWD":/backup alpine \
  tar czf /backup/hindsight-bank.tgz -C /data .
docker start hindsight

Punkt montowania w kontenerze tar (/data) jest dowolny; po prostu aliasuje wolumen nazwany, aby tar mógł go odczytać. Aby przywrócić, zatrzymaj kontener, wyczyść wolumen i wypakuj archiwum z powrotem do niego, lub skieruj kontener na zewnętrzne przywracanie PostgreSQL z Opcji B.

Robić snapshot w trzech momentach, zamiast według harmonogramu kalendarzowego: przed zmianą modelu osadzania, przed główną aktualizacją Hindsight lub PostgreSQL i przed przebiegiem reflect lub konsolidacji, który przepisuje bank. Kopia zapasowa, którą przywrócono do banku roboczego, jest warta więcej niż taka, którą tylko zapisano.

Eksport, import i migracja banku pamięci

Kopie zapasowe i przywracanie chronią bank w miejscu. Eksport/import przenosi go między instancjami Hindsight, a to jest to, co zmiana modelu faktycznie zmusza cię zrobić.

Zmiana modelu osadzania to nie edycja konfiguracji. Wektory w banku były wyliczane starym modelem, a inny model — na przykład dostarczony 384-wymiarowy osadnik BGE w przeciwieństwie do 1024-wymiarowego Qwen3-Embedding-0.6B — pisze w inną przestrzeń i zwykle inną szerokość. Nie możesz ponownie skierować istniejącej instancji na nowy osadnik i zachować starych wektorów; wymiary muszą być przeliczone przez przeosadzenie każdej pamięci nowym modelem osadzania.

Ponieważ osadnik i jego konfiguracja są ustawiane per instancja Hindsight, czystą ścieżką jest postawienie nowej instancji z nową konfiguracją osadzania i migracja banku do niej, a nie odbudowywanie wektorów w tej, która już serwuje recall. API Hindsight może również przenieść bank, ale dla jednorazowej zmiany eksport/import jest łatwiejszą i bardziej inspekcyjną ścieżką:

# export the bank from the old instance
docker exec hindsight \
  hindsight-admin export-bank \
    --bank hermes2 \
    --output /tmp/hermes2.zip

docker cp hindsight:/tmp/hermes2.zip ./hermes2.zip

ls -lh hermes2.zip
unzip -t hermes2.zip

# import the bank into the new instance
docker cp ./hermes2.zip hindsight-q06:/tmp/hermes2.zip

docker exec hindsight-q06 \
  hindsight-admin import-bank \
    --archive /tmp/hermes2.zip

unzip -t weryfikuje archiwum, zanim wyślesz je do nowej instancji. Po imporcie, ponownie skieruj Hermes na api_url nowej instancji w ~/.hermes/hindsight/config.json, zrestartuj bramkę i uruchom walidację pamięci z wcześniejszej sekcji: utrwalony fakt powinien przywołać się przez nowy osadnik. Zostaw stary bank i jego wektory w starej instancji, dopóki nowa nie zachowuje się prawidłowo, więc nadal masz działający fallback.

Monitorowanie, przycinanie i utrzymanie stabilności banku

Gdy bank działa, codzienna praca to obserwowanie tego, co model wyodrębniania zdecydował przechować i utrzymanie pochodnego stanu pod kontrolą. Używaj UI warstwy kontrolnej (hindsight-embed -p hermes ui start), aby inspekcjonować obserwacje, oceny trafności i wynik konsolidacji, zamiast zakładać, że memory status dowodzi, że ingest i recall są poprawne. Zduplikowane lub przestarzałe pamięci to zwykle słabe wyodrębnianie lub niedostatecznie uruchomiona konsolidacja, więc napraw poziom wyodrębniania lub częstotliwość konsolidacji, zanim poszerzysz wyszukiwanie.

Dwa pułapki konserwacyjne warto przetestować przed poleganiem na banku. Po pierwsze, usuwanie obserwacji nie gwarantuje, że wszystkie pochodne reprezentacje znikną z nią — fakt reflect lub krawędź grafu zbudowana z niej może przeżyć usunięcie, więc weryfikuj usunięcie od początku do końca, to samo zagadnienie pochodzenia omówione w pętlach samowzmacniającej się pamięci. Po drugie, zachowuj HINDSIGHT_API_WORKER_ID stabilne podczas odtwarzania i przypinaj konkretną etykietę obrazu: zadanie, które było w trakcie, gdy kontener padł, pozostaje zablokowane pod starą identyfikacją pracownika, a zmienna etykieta to złe dopasowanie dla bazy danych, którą zamierzasz zachować.

Referencje

• Źródło i dokumentacja Hindsight
• Oficjalny przewodnik instalacji Hindsight
• Referencja konfiguracji Hindsight
• Integracja Hindsight z Hermes
• Modele inferencji i dostawcy ponownego sortowania Hindsight
• pgvector
• Serwer llama.cpp
• Ollama