v0.58.0 — Semantic session search with go-vector (RandomProjections + k-NN)

Author: molty3000

cmd/odek/main.go

@@ -1872,6 +1872,8 @@ func continueCmd(args []string) error {
 	if err != nil {
 		return fmt.Errorf("session store: %w", err)
 	}
+	// Initialize semantic search index (non-fatal on failure).
+	_ = store.InitVectorIndex()
 
 	var sess *session.Session
 	if sessionID != "" {

cmd/odek/session_search_tool.go

@@ -24,7 +24,7 @@ func newSessionSearchTool(store *session.Store) *sessionSearchTool {
 }
 
 func (t *sessionSearchTool) Name() string        { return "session_search" }
-func (t *sessionSearchTool) Description() string  { return `Search and retrieve past agent sessions. Actions: list (recent sessions), search (keyword search), get (full session by ID), find (sessions by task/title). Use this when the user asks about previously discussed topics.` }
+func (t *sessionSearchTool) Description() string  { return `Search and retrieve past agent sessions. Actions: list (recent sessions), search (semantic keyword search through full message content), get (full session by ID), find (sessions by task/title). Uses semantic vector search for the search action — it finds sessions whose conversation content is relevant to your query, even when titles don't match. Use OR between keywords for broad recall.` }
 
 type sessionSearchArgs struct {
 	Action string `json:"action"`          // list, search, get, find
@@ -43,6 +43,7 @@ type sessionSummary struct {
 
 type sessionSearchResult struct {
 	Action   string           `json:"action"`
+	Query    string           `json:"query,omitempty"` // echoed back for the LLM
 	Sessions []sessionSummary `json:"sessions,omitempty"`
 	Count    int              `json:"count"`
 	// For get action — full session details
@@ -154,6 +155,42 @@ func (t *sessionSearchTool) handleSearch(query string, limit int) (string, error
 
 	tokens := strings.Fields(strings.ToLower(query))
 
+	// Phase 1: Vector search — semantic matching over conversation content.
+	// This finds sessions whose message content is semantically similar to
+	// the query, even when no keywords match the session title.
+	if t.store.Vec != nil && t.store.Vec.Ready() {
+		vecResults, err := t.store.Vec.Search(query, limit)
+		if err == nil && len(vecResults) > 0 {
+			// Load full session metadata for each result.
+			results := make([]sessionSummary, 0, len(vecResults))
+			for _, vr := range vecResults {
+				sess, err := t.store.Load(vr.SessionID)
+				if err != nil || sess == nil {
+					continue
+				}
+				scoreLabel := fmt.Sprintf("(score: %.3f)", vr.Score)
+				results = append(results, sessionSummary{
+					ID:        sess.ID,
+					Task:      sess.Task + " " + scoreLabel,
+					Turns:     sess.Turns,
+					CreatedAt: sess.CreatedAt.UTC().Format(time.RFC3339),
+					UpdatedAt: sess.UpdatedAt.UTC().Format(time.RFC3339),
+					Model:     sess.Model,
+				})
+			}
+			if len(results) > 0 {
+				return jsonResult(sessionSearchResult{
+					Action:   "search",
+					Query:    query,
+					Sessions: results,
+					Count:    len(results),
+				})
+			}
+		}
+		// Vector search returned no results — fall through to keyword.
+	}
+
+	// Phase 2: Keyword search (existing logic — title + deep scan).
 	// Get generous candidate list
 	listLimit := limit * 4
 	if listLimit < 20 {
@@ -169,7 +206,7 @@ func (t *sessionSearchTool) handleSearch(query string, limit int) (string, error
 		})
 	}
 
-	// Phase 1: score by task + buffer
+	// Phase 2a: score by task + buffer
 	var matches []sessionMatch
 	for _, s := range sessions {
 		m := t.scoreSession(tokens, s)
@@ -178,7 +215,7 @@ func (t *sessionSearchTool) handleSearch(query string, limit int) (string, error
 		}
 	}
 
-	// Phase 2: if not enough results, load full sessions and search messages
+	// Phase 2b: if not enough results, load full sessions and search messages
 	if len(matches) < limit {
 		matches = t.deepSearch(tokens, sessions, matches, limit)
 	}
@@ -211,6 +248,7 @@ func (t *sessionSearchTool) handleSearch(query string, limit int) (string, error
 
 	return jsonResult(sessionSearchResult{
 		Action:   "search",
+		Query:    query,
 		Sessions: results,
 		Count:    len(results),
 	})

cmd/odek/telegram.go

@@ -140,6 +140,12 @@ func telegramCmd(args []string) error {
 		return err
 	}
 
+	// Initialize semantic search index.
+	if err := store.InitVectorIndex(); err != nil {
+		fmt.Fprintf(os.Stderr, "odek telegram: vector index: %v\n", err)
+		// Non-fatal — search falls back to metadata-only.
+	}
+
 	// 6. Create session manager (per-chat Telegram session cache)
 	//    with the configured session TTL (default 24h).
 	sessionManager := telegram.NewSessionManager(store, time.Duration(cfg.SessionTTL)*time.Hour)

docs/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## v0.58.0 (2026-05-26) — Semantic Session Search (go-vector)
+
+### Features
+- **Semantic session search** — `session_search` now uses go-vector's RandomProjections embedder to find sessions by semantic similarity of their conversation content, not just keyword matching on titles. A search for "code review" now finds sessions discussing code review, even when their titles are "tg-8592463065".
+- **Automatic vector indexing** — every session Save() embeds the user+assistant conversation text using a pure-Go random projection (Achlioptas 2003) and persists the vector in `~/.odek/sessions/vectors.gob`. New sessions are indexed automatically. Index is rebuilt from scratch on first startup, then loaded from persisted gob files.
+- **`BuildConversationText()`** — new helper extracts user queries + assistant responses for embedding, excluding system prompts and tool noise.
+
+### Infrastructure
+- **`go-vector` upgraded v1.1.1→v1.2.0** — adds `SaveEmbedder()`/`LoadEmbedder()` methods to RandomProjections for embedder state persistence (seed 42 deterministic, 256-dim sparse random projection).
+- **`internal/session/vector_index.go`** — new VectorIndex type wrapping go-vector's Store + RandomProjections with Init/Add/Remove/Search/Save lifecycle. Thread-safe.
+
+### Testing
+- **5 new tests** — `TestNewVectorIndex_Search` (semantic ranking), `TestVectorIndex_Remove` (idempotent delete), `TestVectorIndex_Persistence` (survives restart), `TestVectorIndex_EmptySearch` (graceful on empty), `TestBuildConversationText` (user/assistant only).
+
 ## v0.57.0 (2026-05-26) — search_files & multi_grep Performance
 
 ### Performance

go.mod

@@ -4,7 +4,7 @@ go 1.25.0
 
 require (
 	github.com/BackendStack21/go-mcp v1.1.0
-	github.com/BackendStack21/go-vector v1.1.1
+	github.com/BackendStack21/go-vector v1.2.0
 	golang.org/x/net v0.54.0
 	golang.org/x/term v0.43.0
 )

go.sum

@@ -2,6 +2,8 @@ github.com/BackendStack21/go-mcp v1.1.0 h1:NQStOkqUWjzzzmySnfFHvPKhbKr92iBuPJjkN
 github.com/BackendStack21/go-mcp v1.1.0/go.mod h1:RKFw6nrl6ySQqqrR8KtG7HYZ/heyyjT8SjiEtlbTMY8=
 github.com/BackendStack21/go-vector v1.1.1 h1:sycI+a/ifT2DD3kdH0HleWtjKmIVNutvL/pgOL9qTA8=
 github.com/BackendStack21/go-vector v1.1.1/go.mod h1:+IzfAFO4m6xrjsOhZsiTAbMbm8+hX0d9C1uD0SGPzHc=
+github.com/BackendStack21/go-vector v1.2.0 h1:Zq6J/x7/OlAmVYC5t6VX64cf6V9rkSU2sR6nz49Fu+I=
+github.com/BackendStack21/go-vector v1.2.0/go.mod h1:+IzfAFO4m6xrjsOhZsiTAbMbm8+hX0d9C1uD0SGPzHc=
 golang.org/x/net v0.54.0 h1:2zJIZAxAHV/OHCDTCOHAYehQzLfSXuf/5SoL/Dv6w/w=
 golang.org/x/net v0.54.0/go.mod h1:Sj4oj8jK6XmHpBZU/zWHw3BV3abl4Kvi+Ut7cQcY+cQ=
 golang.org/x/sys v0.44.0 h1:ildZl3J4uzeKP07r2F++Op7E9B29JRUy+a27EibtBTQ=

internal/session/session.go

@@ -53,6 +53,11 @@ type Session struct {
 type Store struct {
 	dir string // e.g. /home/user/.odek/sessions/
 	mu  sync.Mutex
+
+	// Vec is the optional semantic search index. When non-nil, every
+	// Save/Delete/Cleanup call updates the vector index automatically.
+	// Call InitVectorIndex() to initialize.
+	Vec *VectorIndex
 }
 
 // NewStore creates a session store rooted at ~/.odek/sessions/.
@@ -69,6 +74,17 @@ func NewStore() (*Store, error) {
 	return &Store{dir: dir}, nil
 }
 
+// InitVectorIndex initializes the semantic search index. Must be called
+// after NewStore, before the first Save. Safe to call multiple times —
+// subsequent calls are no-ops.
+func (s *Store) InitVectorIndex() error {
+	if s.Vec != nil && s.Vec.Ready() {
+		return nil // already initialized
+	}
+	s.Vec = new(VectorIndex)
+	return s.Vec.Init(s.dir)
+}
+
 // ── ID Generation ──────────────────────────────────────────────────────
 
 // generateID creates a session ID: YYYYMMDD-<random 3 bytes hex>.
@@ -293,7 +309,18 @@ func (s *Store) saveLocked(sess *Session) error {
 	// Update the index atomically.
 	idx := s.loadIndex()
 	idx[sess.ID] = indexEntry(sess)
-	return s.saveIndexLocked(idx)
+	if err := s.saveIndexLocked(idx); err != nil {
+		return err
+	}
+
+	// Update the vector index for semantic search.
+	if s.Vec != nil {
+		if err := s.Vec.Add(sess.ID, sess.Messages); err != nil {
+			return fmt.Errorf("session: vector index add: %w", err)
+		}
+	}
+
+	return nil
 }
 
 // Load reads a session from disk by ID. Returns an error if the file
@@ -443,7 +470,16 @@ func (s *Store) Delete(id string) error {
 	// Remove from index atomically.
 	idx := s.loadIndex()
 	delete(idx, id)
-	return s.saveIndexLocked(idx)
+	if err := s.saveIndexLocked(idx); err != nil {
+		return err
+	}
+
+	// Remove from vector index.
+	if s.Vec != nil {
+		_ = s.Vec.Remove(id) // best-effort
+	}
+
+	return nil
 }
 
 // Cleanup deletes all sessions whose UpdatedAt is before the given time.