agentverse-memory

Give any AI agent persistent, graph-native memory via Agentverse Memory — a managed MCP service with 35 JSON-RPC tools covering 4 memory types (episodic, semantic/graph, procedural, working) plus shared multi-agent memory spaces. Zero LLM at write time (<5ms writes, $0 ingest). Graph memory on every tier — including free. Hybrid retrieval (TF-IDF + dense, RRF-fused). Requires AM_API_KEY env var. Use when asked to store memories, recall past events, build a knowledge graph, share memory between agents, or retrieve facts about users/tasks.

설치로 이동

저장소: fetchai/agentverse-skills
최근 소스 활동: 2026년 6월 30일 11:55
감지된 SKILL.md 언어: 영어
스타: 2
포크: 2

설치 방법

기본적으로 소스를 먼저 확인하는 Prompt가 선택됩니다. 직접 명령으로 전환하거나 로컬 사본을 다운로드할 수도 있습니다.

소스 파일 검토

설치 여부를 결정하기 전에 SKILL.md와 SkillsMP에 표시된 보조 파일을 읽어 보세요.

검색으로 돌아가기 설치로 돌아가기

name	agentverse-memory
description	Give any AI agent persistent, graph-native memory via Agentverse Memory — a managed MCP service with 35 JSON-RPC tools covering 4 memory types (episodic, semantic/graph, procedural, working) plus shared multi-agent memory spaces. Zero LLM at write time (<5ms writes, $0 ingest). Graph memory on every tier — including free. Hybrid retrieval (TF-IDF + dense, RRF-fused). Requires AM_API_KEY env var. Use when asked to store memories, recall past events, build a knowledge graph, share memory between agents, or retrieve facts about users/tasks.
license	Apache-2.0
compatibility	Python 3.9+, network access, AM_API_KEY env var
metadata	{"version":"1.3.2","author":"Fetch.ai","last-updated":"2026-06-30"}
allowed-tools	Read Bash(python3 ) Bash(curl ) Bash(mem *) Bash(pip install requests)

Agentverse Memory

Overview

Give any AI agent persistent, graph-native memory. Agentverse Memory is a managed MCP service that exposes 35 JSON-RPC 2.0 tools for:

Memory Type	What it stores	Key tools
Episodic	Time-stamped events, observations, conversations	`memory_store_episode`, `memory_search_episodes`
Entity	Named entities with typed properties	`memory_store_entity`, `memory_get_entity`
Graph	Knowledge graph triples, traversal, pathfinding	`memory_traverse_graph`, `memory_find_path`
Procedural	Goal-directed skill sequences with outcome tracking	`memory_store_procedure`, `memory_match_procedure`
Working	Ephemeral key-value scratchpad (TTL-aware)	`memory_set_working`, `memory_get_working`
Shared	Multi-agent shared knowledge spaces	`memory_create_shared_space`, `memory_shared_query`
Pheromone	Stigmergic trails on memory paths	`memory_deposit_pheromone`, `memory_get_pheromone`

AM_API_KEY environment variable set (prefix: am_)

Get a free key (real response shape shown below):

curl -X POST https://am-server-jbneh74b5q-uc.a.run.app/v1/keys \
  -H "Content-Type: application/json" \
  -d '{"agent_id":"my-agent","tier":"explorer"}'
# → {"agent_id":"my-agent","key":"am_xxxxxxxx","key_id":"...",
#    "monthly_op_limit":50000,"tier":"explorer","warning":"Store this key securely..."}

The field is key (not api_key) and the limit is monthly_op_limit (not ops_per_month).

Python 3.9+ with requests:
```
pip install requests
```

curl -X POST https://am-server-jbneh74b5q-uc.a.run.app/v1/keys \
  -H "Content-Type: application/json" \
  -d '{"agent_id": "my-agent", "tier": "explorer"}'
# → {"agent_id":"my-agent","key":"am_xxxxxxxxxxxxxxxx","key_id":"...",
#    "monthly_op_limit": 50000, "tier": "explorer", "warning": "..."}

# Export the value of the "key" field:
export AM_API_KEY="am_xxxxxxxxxxxxxxxx"

curl https://am-server-jbneh74b5q-uc.a.run.app/health
# → {"service":"am-server","status":"ok","version":"0.1.0"}

python3 skills/agentverse-memory/scripts/memory_client.py store-episode \
  --agent-id "my-agent" \
  --content "User Alice asked about quantum computing and preferred simple analogies"

python3 skills/agentverse-memory/scripts/memory_client.py query-episodes \
  --agent-id "my-agent" \
  --query "quantum computing preferences" \
  --limit 5
# Result includes "retrieval":"hybrid" (TF-IDF ∪ dense, RRF-fused).
# Add --no-hybrid to force lexical-only, or --use-pheromone for warm-cache re-ranking.

python3 skills/agentverse-memory/scripts/memory_client.py store-fact \
  --agent-id "my-agent" \
  --subject "Alice" \
  --predicate "prefers_explanation_style" \
  --object "simple analogies"

python3 skills/agentverse-memory/scripts/memory_client.py find-path \
  --agent-id "my-agent" \
  --start "Alice" \
  --end "quantum computing"
# A* pathfinding requires the Builder tier or above. On the free Explorer tier
# use traverse-graph (BFS), which is available everywhere.

python3 skills/agentverse-memory/scripts/memory_client.py set-working \
  --agent-id "my-agent" \
  --key "current_task" \
  --value '{"task": "write report", "status": "in_progress"}' \
  --ttl 3600

curl -X POST https://am-server-jbneh74b5q-uc.a.run.app/mcp \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $AM_API_KEY" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/call",
    "params": {
      "name": "memory_store_episode",
      "arguments": {
        "agent_id": "my-agent",
        "content": "User prefers dark mode in all interfaces",
        "source": "user"
      }
    }
  }'

export AM_BASE_URL="https://am-server-jbneh74b5q-uc.a.run.app"   # MEM_URL is derived as $AM_BASE_URL/mcp
export AM_API_KEY="am_xxxxxxxxxxxxxxxx"

mem doctor                                            # validate the onboarding chain
mem episode "User prefers dark mode" '{"tags":["pref"]}'
mem search "dark mode"
mem stats

# NOT YET PUBLISHED — do not use yet:
#   pip install agentverse-memory          (PyPI package not live)
#   npm install @fetchai/agentverse-memory (npm package not live)

Tool	Description
`memory_store_episode`	Store a time-stamped event or observation
`memory_get_episodes`	Retrieve episodes by agent, with pagination
`memory_search_episodes`	Natural-language search — hybrid retrieval (TF-IDF ∪ dense embeddings, RRF-fused)
`memory_search_timeline`	Search within a specific time window
`memory_consolidate_episodes`	Merge related episodes into a summary

Tool	Description
`memory_store_entity`	Store a named entity with typed properties
`memory_get_entity`	Retrieve entity by name or ID
`memory_list_entities`	List entities with prefix/type filter
`memory_store_relation`	Store a typed relationship between two entities (by entity ID)
`memory_get_relations`	Get all relations for an entity

Tool	Description
`memory_query_graph`	Keyword graph query over stored triples
`memory_semantic_search`	Vector similarity search across memory types
`memory_get_neighbors`	Get direct neighbors of a graph node
`memory_find_path`	A* pathfinding between concepts (pheromone/shortest/semantic) — Builder+ tier
`memory_traverse_graph`	BFS outward from a start node (free on every tier)

Tool	Description
`memory_graph_add_triple`	Add a (subject, predicate, object) triple directly
`memory_graph_neighbors`	Get low-level graph neighbors of a node
`memory_graph_shortest_path`	Shortest path between two nodes

Tool	Description
`memory_store_procedure`	Store a named, goal-directed step sequence
`memory_get_procedure`	Retrieve procedure with success/fail stats
`memory_match_procedure`	Find the best procedure for a task description
`memory_update_procedure`	Update steps or record execution outcome

Tool	Description
`memory_set_working`	Set key-value with optional TTL (<1ms p50)
`memory_get_working`	Get value by key
`memory_list_working`	List all keys (with prefix filter)
`memory_clear_working`	Delete one key, by prefix, or all

Tool	Description
`memory_create_shared_space`	Create a multi-agent shared knowledge space
`memory_join_shared_space`	Join a space by `space_id` (your JWT must grant access — see Shared Spaces & JWT Authentication)
`memory_shared_store_entity`	Store an entity in a shared space
`memory_shared_query`	Query cross-agent memory within a shared space
`memory_list_shared_spaces`	List shared spaces the agent belongs to

Param	Type	Default	Notes
`query`	string	—	Required search text
`limit`	integer	12	Max evidence items to return
`use_hybrid`	boolean	`true`	Fuse the TF-IDF candidate set with dense embeddings (RRF). Set `false` for lexical-only.
`use_pheromone`	boolean	`false`	Re-rank by pheromone weight. Best for warm/repeated-access workloads; off by default.
`max_content_chars`	integer	—	Optional: trim each result's content to N chars to save tokens

Tool	Parameter	Type	Req	Default	Description
`memory_store_episode`	`content`	string	✅	—	Episode text content
	`metadata`	object	—	—	Structured metadata (chunk provenance merged in when content is split)
	`valid_at`	string	—	now	Validity timestamp (RFC3339)
	`chunk`	boolean	—	auto	Force (`true`) / disable (`false`) chunking; auto = chunk only when content > `chunk_threshold`
	`chunk_threshold`	integer	—	6000	Auto-chunk content longer than this many chars
	`chunk_size`	integer	—	2800	Target chunk size (chars)
	`chunk_overlap`	integer	—	450	Overlap between consecutive chunks (chars)
`memory_get_episodes`	`limit`	integer	—	10	Max episodes to return (most recent first)
`memory_search_episodes`	`query`	string	✅	—	Search text — full detail in the table above
	`limit`	integer	—	12	Max evidence items to return
	`use_hybrid`	boolean	—	server default (ON in prod)	Fuse TF-IDF ∪ dense embeddings (RRF)
	`use_pheromone`	boolean	—	server default (OFF in prod)	Re-rank by pheromone weight
	`max_content_chars`	integer	—	no trim	Trim each result's content to N chars
`memory_search_timeline`	`start_time`	string	✅	—	Window start (RFC3339)
	`end_time`	string	✅	—	Window end (RFC3339)
`memory_consolidate_episodes`	`before_time`	string	—	7 days ago	Consolidate episodes older than this (RFC3339); those with pheromone weight < 0.1 are soft-deleted

Tool	Parameter	Type	Req	Default	Description
`memory_store_entity`	`entity_id`	string	✅	—	Unique entity identifier / name
	`type`	string	—	`"concept"`	Entity type
	`description`	string	—	—	Human-readable description
	`predicate`	string	—	—	Predicate (for subject-predicate-object facts)
	`object_value`	string	—	—	Object value (for subject-predicate-object facts)
	`properties`	object	—	—	Structured metadata (alias of `metadata`)
	`metadata`	object	—	—	Structured metadata (takes precedence if both are sent)
`memory_get_entity`	`entity_id`	string	✅	—	Entity id/name to fetch (returns `found:false` if absent)
`memory_list_entities`	`limit`	integer	—	20	Max entities to return
`memory_store_relation`	`from_id`	string	✅	—	Source entity (UUID or name; a new name is auto-created as a stub)
	`to_id`	string	✅	—	Target entity (UUID or name; auto-created if new)
	`predicate`	string	✅	—	Relation label
	`weight`	number	—	1.0	Edge weight
`memory_get_relations`	`entity_id`	string	✅	—	Entity id/name whose relations to fetch

Tool	Parameter	Type	Req	Default	Description
`memory_query_graph`	`query`	string	✅	—	Keyword graph query text
`memory_semantic_search`	`query`	string	✅	—	Search text (TF-IDF over entities)
	`limit`	integer	—	10	Max results
`memory_get_neighbors`	`entity_id`	string	✅	—	Entity id/name to expand from
	`hops`	integer	—	1	Neighbor hop depth
`memory_find_path` †	`from_id`	string	✅	—	Source node identifier
	`to_id`	string	✅	—	Target node identifier
	`max_hops`	integer	—	6	Maximum path length (hops)
`memory_traverse_graph`	`start_id`	string	✅	—	Starting node identifier
	`algorithm`	string `"bfs"`\|`"dfs"`	—	`"bfs"`	Traversal algorithm
	`max_depth`	integer	—	3	Maximum traversal depth

Tool	Parameter	Type	Req	Default	Description
`memory_graph_add_triple`	`subject`	string	✅	—	Subject node label
	`predicate`	string	✅	—	Predicate / edge label
	`object`	string	✅	—	Object node label
`memory_graph_neighbors`	`node`	string	✅	—	Starting node label
	`depth`	integer	—	1	Hop depth (1–5; capped at 5)
	`direction`	string `"outgoing"`\|`"incoming"`\|`"both"`	—	`"outgoing"`	Edge direction
`memory_graph_shortest_path`	`from`	string	✅	—	Source node label
	`to`	string	✅	—	Target node label
	`undirected`	boolean	—	false	Traverse edges in both directions

Tool	Parameter	Type	Req	Default	Description
`memory_store_procedure`	`name`	string	✅	—	Procedure name
	`description`	string	—	—	Description
	`steps`	array<string\|object>	—	`[]`	Ordered steps: plain strings, or objects `{action, tool?, expected_output?}`
	`tags`	array<string>	—	`[]`	Tags
	`preconditions`	array<string>	—	`[]`	Preconditions
`memory_get_procedure`	`procedure_id`	string	✅*	—	Procedure UUID — one of `procedure_id` / `name` required
	`name`	string	✅*	—	Procedure name (alternative to `procedure_id`)
`memory_match_procedure`	`task`	string	✅	—	Task description to match against stored procedures
	`limit`	integer	—	5	Max procedures to return
`memory_update_procedure`	`procedure_id`	string	✅*	—	Procedure UUID to update — one of `procedure_id` / `name` required
	`name`	string	✅*	—	Procedure name (alternative to `procedure_id`)
	`steps`	array<string\|object>	✅	—	New ordered steps (replaces old; creates a new version)
	`reason`	string	—	—	Reason for the update

Tool	Parameter	Type	Req	Default	Description
`memory_set_working`	`key`	string	✅	—	Working memory key
	`content`	string	✅	—	Value to store (`value` accepted as a legacy alias; non-strings are JSON-encoded)
	`ttl_seconds`	integer	—	none (no expiry)	Time-to-live in seconds
	`session_id`	string	—	—	Optional session scope
`memory_get_working`	`key`	string	✅	—	Key to fetch (returns `found:false` if absent/expired)
`memory_list_working`	(none)	—	—	—	Lists all live working-memory items
`memory_clear_working`	`key`	string	—	—	Key to delete; omit to clear ALL working memory

Tool	Parameter	Type	Req	Default	Description
`memory_deposit_pheromone`	`node_id`	string	✅	—	Episode UUID or entity name/ID to reinforce
	`strength`	number	—	1.0	Pheromone deposit strength
`memory_get_pheromone`	`node_id`	string	✅	—	Episode UUID or entity name/ID to query

Tool	Parameter	Type	Req	Default	Description
`memory_create_shared_space`	`name`	string	✅	—	Space name (1–128 characters)
`memory_join_shared_space`	`space_id`	string	✅	—	Space ID to join (JWT must grant access to it)
	`role`	string `"owner"`\|`"writer"`\|`"reader"`	—	`"writer"`	Requested role
`memory_shared_store_entity`	`space_id`	string	✅	—	Space ID (requires writer/owner role)
	`name`	string	✅	—	Entity name
	`entity_type`	string	—	`"thing"`	Entity type
	`description`	string	—	—	Description
`memory_shared_query`	`space_id`	string	✅	—	Space ID (requires reader/writer/owner role)
	`query`	string	—	`""` (list all)	Search query; empty/omitted lists all entities
	`limit`	integer	—	10	Max results
`memory_list_shared_spaces`	(none)	—	—	—	Lists shared spaces the agent belongs to

Tool	Parameter	Type	Req	Default	Description
`memory_get_stats`	(none)	—	—	—	Usage stats, memory counts, rate-limit status
`memory_delete_agent`	`confirm`	boolean	✅	—	Must be `true` to permanently delete all of this agent's memory (irreversible, GDPR)

Tool	Success payload (`structuredContent`)
`memory_store_episode`	`{ stored:true, id:"<uuid>", ids:["<uuid>", …], chunks:<int>, agent_id }` — `id` = first/only episode; `ids`/`chunks` reflect auto-chunking
`memory_get_episodes`	`{ episodes:[ <Episode> … ], count:<int> }` (outputSchema)
`memory_search_episodes`	`{ results:[ { episode, score, … } … ], count:<int>, retrieval:"hybrid"\|"tfidf" }` (outputSchema)
`memory_search_timeline`	`{ episodes:[ … ], count:<int>, window:{ start, end } }`
`memory_consolidate_episodes`	`{ consolidated:<int>, before:"<rfc3339>", note }`

Tool	Success payload
`memory_store_entity`	`{ id:"<uuid>", entity_id, stored:true }`
`memory_get_entity`	found → `{ entity:<Entity>, found:true }` · absent → `{ found:false, entity_id }`
`memory_list_entities`	`{ entities:[ … ], count:<int> }` (outputSchema)
`memory_store_relation`	`{ id:"<uuid>", from_id, to_id, predicate, stored:true }`
`memory_get_relations`	`{ relations:[ … ], count:<int>, entity_id }`

Tool	Success payload
`memory_query_graph`	Backend graph-query result object (matched nodes/edges; shape is backend-defined)
`memory_semantic_search`	`{ results:[ { entity, score } … ], count:<int> }` (outputSchema)
`memory_get_neighbors`	`{ neighbors:[ … ], count:<int>, entity_id, hops:<int> }`
`memory_find_path`	`{ path:[ … ], hops:<int>, from_id, to_id }` (Builder+ tier-license; Explorer → in-band `-32002 forbidden`, fall back to `memory_traverse_graph`)
`memory_traverse_graph`	`{ visited:[ … ], count:<int>, start_id, algorithm, max_depth:<int> }`

Tool	Success payload
`memory_graph_add_triple`	`{ stored:true, triple_id:"<uuid>", subject, predicate, object }`
`memory_graph_neighbors`	`{ node, depth:<int>, direction, count:<int>, neighbors:[ { subject, predicate, object } … ] }`
`memory_graph_shortest_path`	`{ from, to, undirected:<bool>, found:<bool>, hops:<int>, path:[ … ] }`

Tool	Success payload
`memory_store_procedure`	`{ id:"<uuid>", name, stored:true }`
`memory_get_procedure`	found → `{ procedure:<Procedure>, found:true }` · absent → `{ found:false, procedure_id }`
`memory_match_procedure`	`{ results:[ … ], count:<int> }`
`memory_update_procedure`	`{ new_id:"<uuid>", old_procedure_id, updated:true }` (creates a new version)

Tool	Success payload
`memory_set_working`	`{ key, set:true, ttl_seconds }`
`memory_get_working`	found → `{ item:<WorkingItem>, found:true }` · absent/expired → `{ found:false, key }`
`memory_list_working`	`{ items:[ … ], count:<int> }`
`memory_clear_working`	single key → `{ key, removed:<bool> }` · clear-all → `{ cleared:true, keys_deleted:<int> }`

Tool	Success payload
`memory_deposit_pheromone`	`{ node_id, new_weight:<float>, node_type:"episode"\|"entity" }`
`memory_get_pheromone`	found → `{ node_id, weight:<float>, node_type }` · absent → `{ node_id, found:false }`

Tool	Success payload
`memory_create_shared_space`	`{ space_id, name, owner_did, members:<int>, created_at:"<rfc3339>", status:"created" }`
`memory_join_shared_space`	`{ space_id, agent_did, role, members:<int>, status:"joined" }`
`memory_shared_store_entity`	`{ space_id, entity_id:"<uuid>", name, entity_type, stored_by, status:"stored" }`
`memory_shared_query`	`{ space_id, query, count:<int>, results:[ { id, name, entity_type, description, score? } … ] }` (`score` present only for non-empty queries)
`memory_list_shared_spaces`	`{ agent_did, count:<int>, spaces:[ { space_id, name, owner_did, my_role, member_count, created_at } … ] }`

Tool	Success payload
`memory_get_stats`	`{ agent_id, tier, monthly_ops_used:<int>, monthly_op_limit:<int>, memory:{ episode_count, entity_count, relation_count, procedure_count, working_count } }` (outputSchema)
`memory_delete_agent`	`{ agent_id, deleted:true, note }`

{ "jsonrpc": "2.0", "id": 1, "method": "initialize",
  "params": { "protocolVersion": "2026-07-28", "capabilities": {},
              "clientInfo": { "name": "my-client", "version": "1.0" } } }

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "memory_store_episode",
    "arguments": { "agent_id": "...", "content": "..." }
  }
}

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "content": [{ "type": "text", "text": "{\"stored\":true,\"id\":\"5d9d...\"}" }],
    "isError": false,
    "structuredContent": { "stored": true, "id": "5d9d...", "ids": ["5d9d..."], "chunks": 1 }
  }
}

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "content": [{ "type": "text", "text": "validation error on 'task': required field missing or invalid" }],
    "isError": true,
    "structuredContent": { "error": { "code": -32004, "type": "validation_error",
                                       "message": "validation error on 'task': ..." } }
  }
}

Single-agent tools (30): authenticate with your API key (X-API-Key: am_… or Authorization: Bearer am_…). Fully self-serve via POST /v1/keys.
Shared-space tools (5): require a JWT (Authorization: Bearer <jwt>). The server gates access in two steps — tier first, then JWT:
- Explorer (free) tier — the tier gate fires first: any shared-space tool call returns an in-band -32002 forbidden ("forbidden: tier 'explorer' cannot access 'builder' feature"). No shared spaces on the free tier; upgrade to Builder ($19/mo).
- Builder+ tier without a JWT — the JWT auth gate fires next: returns an in-band -32001 unauthorized:
```
{ "isError": true,
  "structuredContent": { "error": { "code": -32001, "type": "unauthorized",
    "message": "unauthorized: Shared space operations require JWT authentication. Use 'Authorization: Bearer <jwt>' with a valid JWT token." } } }
```

curl -s -X POST https://am-server-jbneh74b5q-uc.a.run.app/v1/space-token \
  -H "X-API-Key: am_YOUR_BUILDER_KEY"
# → { "token": "eyJ...", "token_type": "Bearer",
#     "expires_at": "2026-06-30T12:26:00Z", "expires_in": 3600,
#     "tier": "builder", "agent_id": "agent-abc123", "spaces": [...],
#     "usage": "Use as Authorization: Bearer <token> with shared-space MCP tools" }

Claim	Value / meaning
`sub`	Your agent DID — e.g. `did:fetch:agent123abc`. Derived from your API key.
`iss`	Always `agentverse-memory`.
`aud`	Always `am-server`.
`spaces`	Array of space IDs this token may access (computed server-side). `[]` if you haven't created any yet.
`tier`	Your API key's tier (`builder`\|`pro`\|`enterprise`).
`exp`	Expiry (Unix seconds, numeric — string `exp` is rejected, CVE-2026-25537).
`iat`	Issued-at (Unix seconds).

Tier	Price	Ops/month	Agents	Graph	A* pathfinding	Shared spaces
Explorer	Free	50,000	3	✅ + BFS traversal	❌	❌
Builder	$19/mo	500,000	25	✅	✅ A*	✅
Pro	$99/mo	5,000,000	Unlimited	✅	✅ A*	✅ Unlimited
Enterprise	Custom	Custom	Unlimited	✅	✅	✅