The cross-harness, self-improving memory layer for AI agents. Join our community: https://discord.com/invite/zdNChS2fBu
Go agent-ai-cliagent-harnessesagent-securitybrowser-extensionciclaude-codecloudcodexcursordetection-engineeringjevknowledge-basememorymobile-device-managementobservabilitysecuritysecurity-information-and-event-managementsecurity-toolstelemetrytraces
Expose approved memory through MCP
Justin D'Souza55ac7b285b66
diff --git a/cli/beacon/internal/endpoint/inventory/heartbeat.go b/cli/beacon/internal/endpoint/inventory/heartbeat.goindex 38fab440..3537932b 100644--- a/cli/beacon/internal/endpoint/inventory/heartbeat.go+++ b/cli/beacon/internal/endpoint/inventory/heartbeat.go@@ -190,9 +190,21 @@ func digestConfigs(configs []Config) []Config {out := make([]Config, len(configs))for i, config := range configs {if config.Volatile {- config.FileSHA256 = ""- config.ModifiedAt = ""- config.Content = nil+ config = Config{+ Runtime: config.Runtime,+ Path: config.Path,+ PathHash: config.PathHash,+ Scope: config.Scope,+ ConfigKind: config.ConfigKind,+ ParserMode: config.ParserMode,+ Exists: config.Exists,+ Readable: config.Readable,+ ParserStatus: config.ParserStatus,+ Volatile: config.Volatile,+ MCPServerCount: config.MCPServerCount,+ BeaconManaged: config.BeaconManaged,+ Redaction: config.Redaction,+ }}out[i] = config}diff --git a/cli/beacon/internal/mcpserver/server.go b/cli/beacon/internal/mcpserver/server.goindex 91c8b3f7..d4a82128 100644--- a/cli/beacon/internal/mcpserver/server.go+++ b/cli/beacon/internal/mcpserver/server.go@@ -16,7 +16,9 @@ import ("time""github.com/asymptote-labs/agent-beacon/cli/beacon/internal/endpoint/activity"+ "github.com/asymptote-labs/agent-beacon/cli/beacon/internal/learning""github.com/asymptote-labs/agent-beacon/cli/beacon/internal/version"+ "github.com/asymptote-labs/agent-beacon/pkg/asymptoteobserve")const (@@ -75,6 +77,27 @@ type textContent struct {Text string `json:"text"`}+type memorySearchResult struct {+ Memories []memorySummary `json:"memories"`+ Returned int `json:"returned"`+ Limit int `json:"limit"`+}++type memoryContextResult struct {+ Context []memorySummary `json:"context"`+ Returned int `json:"returned"`+ Limit int `json:"limit"`+}++type memorySummary struct {+ ID string `json:"id"`+ Kind string `json:"kind"`+ Title string `json:"title"`+ Applicability string `json:"applicability,omitempty"`+ Body string `json:"body,omitempty"`+ Tags []string `json:"tags,omitempty"`+}+func New(opts Options) *Server {server := &Server{logPath: opts.LogPath,@@ -100,7 +123,7 @@ func (s *Server) ToolNames() []string {}func (s *Server) HasExpectedTools() error {- expected := []string{"search_activity", "summarize_activity", "get_activity_event", "list_activity_filters"}+ expected := []string{"search_activity", "summarize_activity", "get_activity_event", "list_activity_filters", "search_memory", "get_memory", "get_memory_context"}for _, name := range expected {if _, ok := s.tools[name]; !ok {return fmt.Errorf("missing MCP tool %q", name)@@ -291,6 +314,131 @@ func (s *Server) registerTools() {return activity.ListFilters(query)},})+ s.register(Tool{+ Name: "search_memory",+ Description: "Search approved Beacon project memory and return compact summaries.",+ InputSchema: memoryQuerySchema("Search filters for approved project memory."),+ handler: func(ctx context.Context, args map[string]interface{}) (interface{}, error) {+ query, err := s.parseMemoryQuery(args)+ if err != nil {+ return nil, err+ }+ memories, err := s.memoryStore().ListMemories(query)+ if err != nil {+ return nil, err+ }+ limit := normalizeMemoryLimit(query.Limit)+ if len(memories) > limit {+ memories = memories[:limit]+ }+ return memorySearchResult{Memories: memorySummaries(memories), Returned: len(memories), Limit: limit}, nil+ },+ })+ s.register(Tool{+ Name: "get_memory",+ Description: "Fetch one approved Beacon memory item by ID.",+ InputSchema: objectSchema(map[string]interface{}{+ "id": map[string]interface{}{"type": "string", "description": "Approved memory ID."},+ }, []string{"id"}),+ handler: func(ctx context.Context, args map[string]interface{}) (interface{}, error) {+ id := stringArg(args, "id")+ if id == "" {+ return nil, errors.New("id is required")+ }+ memory, ok, err := s.memoryStore().GetMemory(id)+ if err != nil {+ return nil, err+ }+ if !ok || memory.SupersededBy != "" {+ return nil, fmt.Errorf("memory not found: %s", id)+ }+ return memory, nil+ },+ })+ s.register(Tool{+ Name: "get_memory_context",+ Description: "Return a small approved-memory context set for the current task.",+ InputSchema: memoryQuerySchema("Task and project filters for approved memory context."),+ handler: func(ctx context.Context, args map[string]interface{}) (interface{}, error) {+ query, err := s.parseMemoryQuery(args)+ if err != nil {+ return nil, err+ }+ if query.Limit <= 0 || query.Limit > 5 {+ query.Limit = 5+ }+ memories, err := s.memoryStore().ListMemories(query)+ if err != nil {+ return nil, err+ }+ if len(memories) > query.Limit {+ memories = memories[:query.Limit]+ }+ return memoryContextResult{Context: memorySummaries(memories), Returned: len(memories), Limit: query.Limit}, nil+ },+ })+}++func (s *Server) memoryStore() *learning.Store {+ return learning.Open(learning.PathForRuntimeLog(s.logPath))+}++func (s *Server) parseMemoryQuery(args map[string]interface{}) (learning.Query, error) {+ limit := intArg(args, "limit")+ if limit <= 0 {+ limit = 5+ }+ query := learning.Query{+ ProjectID: stringArg(args, "project_id"),+ ProjectPath: stringArg(args, "project"),+ Q: firstNonEmpty(stringArg(args, "q"), stringArg(args, "task")),+ Kind: stringArg(args, "kind"),+ Limit: normalizeMemoryLimit(limit),+ }+ if query.ProjectID == "" && query.ProjectPath == "" {+ project, err := learning.ResolveProject("")+ if err != nil {+ return learning.Query{}, err+ }+ query.ProjectID = project.ID+ }+ return query, nil+}++func memoryQuerySchema(description string) map[string]interface{} {+ return objectSchema(map[string]interface{}{+ "limit": map[string]interface{}{"type": "integer", "description": "Maximum number of memories to return."},+ "q": map[string]interface{}{"type": "string", "description": "Free-text query across approved memory."},+ "task": map[string]interface{}{"type": "string", "description": "Current task text used to select relevant memory."},+ "kind": map[string]interface{}{"type": "string", "description": "Memory kind, such as workflow, correction, debugging_pattern, gotcha, or convention."},+ "project": map[string]interface{}{"type": "string", "description": "Project path for memory scoping."},+ "project_id": map[string]interface{}{"type": "string", "description": "Resolved Beacon project ID for memory scoping."},+ }, nil, description)+}++func memorySummaries(memories []asymptoteobserve.LearningMemoryV1) []memorySummary {+ out := make([]memorySummary, 0, len(memories))+ for _, memory := range memories {+ out = append(out, memorySummary{+ ID: memory.ID,+ Kind: memory.Kind,+ Title: memory.Title,+ Applicability: memory.Applicability,+ Body: asymptoteobserve.CleanString(memory.Body, 1200, true),+ Tags: append([]string(nil), memory.Tags...),+ })+ }+ return out+}++func normalizeMemoryLimit(limit int) int {+ if limit <= 0 {+ return 5+ }+ if limit > 20 {+ return 20+ }+ return limit}func parseQuery(logPath string, args map[string]interface{}) (activity.Query, error) {@@ -380,6 +528,15 @@ func stringArg(args map[string]interface{}, key string) string {return strings.TrimSpace(value)}+func firstNonEmpty(values ...string) string {+ for _, value := range values {+ if strings.TrimSpace(value) != "" {+ return strings.TrimSpace(value)+ }+ }+ return ""+}+func intArg(args map[string]interface{}, key string) int {switch value := args[key].(type) {case float64:diff --git a/cli/beacon/internal/mcpserver/server_test.go b/cli/beacon/internal/mcpserver/server_test.goindex 7168d9ab..66835c90 100644--- a/cli/beacon/internal/mcpserver/server_test.go+++ b/cli/beacon/internal/mcpserver/server_test.go@@ -11,6 +11,8 @@ import ("testing""github.com/asymptote-labs/agent-beacon/cli/beacon/internal/endpoint/schema"+ "github.com/asymptote-labs/agent-beacon/cli/beacon/internal/learning"+ "github.com/asymptote-labs/agent-beacon/pkg/asymptoteobserve")func TestServeStdioListsAndCallsTools(t *testing.T) {@@ -69,11 +71,53 @@ func TestExpectedToolsRegistered(t *testing.T) {if err := server.HasExpectedTools(); err != nil {t.Fatalf("HasExpectedTools returned error: %v", err)}- if got := strings.Join(server.ToolNames(), ","); got != "search_activity,summarize_activity,get_activity_event,list_activity_filters" {+ if got := strings.Join(server.ToolNames(), ","); got != "search_activity,summarize_activity,get_activity_event,list_activity_filters,search_memory,get_memory,get_memory_context" {t.Fatalf("ToolNames = %s", got)}}+func TestMCPMemoryToolsSearchGetAndContext(t *testing.T) {+ logPath := filepath.Join(t.TempDir(), "endpoint", "logs", "runtime.jsonl")+ if err := os.MkdirAll(filepath.Dir(logPath), 0755); err != nil {+ t.Fatal(err)+ }+ store := learning.Open(learning.PathForRuntimeLog(logPath))+ memory := asymptoteobserve.LearningMemoryV1{+ ID: "memory-1",+ CandidateID: "candidate-1",+ Kind: asymptoteobserve.LearningMemoryKindDebuggingPattern,+ Title: "Retry package smoke after transient network failure",+ Body: "If package smoke fails with ECONNRESET, inspect the error and rerun once before changing code.",+ Project: asymptoteobserve.LearningProjectV1{ID: "project-1"},+ Tags: []string{"beacon", "cursor"},+ }+ if err := store.PutMemory(memory); err != nil {+ t.Fatal(err)+ }+ server := New(Options{LogPath: logPath})+ search, err := server.callTool(t.Context(), callToolParams{Name: "search_memory", Arguments: map[string]interface{}{"project_id": "project-1", "q": "ECONNRESET"}})+ if err != nil {+ t.Fatalf("search_memory: %v", err)+ }+ if !strings.Contains(search.Content[0].Text, "memory-1") {+ t.Fatalf("search_memory missing memory: %s", search.Content[0].Text)+ }+ get, err := server.callTool(t.Context(), callToolParams{Name: "get_memory", Arguments: map[string]interface{}{"id": "memory-1"}})+ if err != nil {+ t.Fatalf("get_memory: %v", err)+ }+ if !strings.Contains(get.Content[0].Text, "Retry package smoke") {+ t.Fatalf("get_memory missing body: %s", get.Content[0].Text)+ }+ context, err := server.callTool(t.Context(), callToolParams{Name: "get_memory_context", Arguments: map[string]interface{}{"project_id": "project-1", "task": "package smoke retry"}})+ if err != nil {+ t.Fatalf("get_memory_context: %v", err)+ }+ if !strings.Contains(context.Content[0].Text, "memory-1") {+ t.Fatalf("get_memory_context missing memory: %s", context.Content[0].Text)+ }+}+func writeTestLog(t *testing.T, path string, events ...schema.Event) {t.Helper()var data []byte