go-mcp-embedding-parity

Answer

Root cause. The MCP memory.write tool persisted the row directly (a plain insert, ~7ms, no embed call) while the REST handler ran the shared embedding pipeline. The MCP tool had no reference to an embedding service, so ProcessMemory never ran and the stored row carried a NULL vector.

Fix (REST-parity pattern). Three changes, mirroring the REST handler at memory.go:278-302:

1. WriteTool gains an optional embeddingSvc — nil means "no embeddings" (backward compatible), non-nil means the MCP path embeds exactly like REST.
2. ProcessMemory runs synchronously — embed → store vector on the same row → insert. One shared pipeline, so both paths can't drift.
3. embedding_generated is read back from the stored row — len(row.Embedding) > 0, not a local/hardcoded assumption.

// tools.go — MCP memory.write tool (fixed)
type WriteTool struct {
    service      *Service
    embeddingSvc EmbeddingService // optional; nil => plain write
}

func (t *WriteTool) Execute(ctx context.Context, in WriteInput) (*WriteResult, error) {
    if in.ID == "" || in.Content == "" {
        return nil, errors.New("memory: id and content are required")
    }
    m := &Memory{ID: in.ID, Content: in.Content, CreatedAt: time.Now()}
    // 1+2: shared sync pipeline, embedding service threaded through.
    if err := ProcessMemory(ctx, t.service, m, t.embeddingSvc); err != nil {
        return nil, err
    }
    // 3: flag derives from the persisted row (REST-parity pattern).
    return readBack(ctx, t.service, m.ID)
}

// memory.go — the single write pipeline both REST and MCP now use
func ProcessMemory(ctx context.Context, svc *Service, m *Memory, emb EmbeddingService) error {
    if emb != nil {                       // sync, not fire-and-forget
        vec, err := emb.Embed(ctx, m.Content)
        if err != nil {
            return fmt.Errorf("embed: %w", err) // abort => no partial row
        }
        m.Embedding = vec
    }
    if err := svc.store.Insert(ctx, m); err != nil {
        return err
    }
    return nil
}

// readBack — REST handler pattern (memory.go:278-302): trust the stored row.
func readBack(ctx context.Context, svc *Service, id string) (*WriteResult, error) {
    row, err := svc.store.Get(ctx, id)
    if err != nil {
        return nil, err
    }
    return &WriteResult{Memory: row, EmbeddingGenerated: row.HasEmbedding()}, nil
}

REST Service.Write stays identical (calls ProcessMemory with its configured s.emb, then readBack) — so both transports now produce byte-identical stored rows.