"Exploring memories or concepts related to windsurfing" matching MCP tools:

• historyA

  recordariA

  Return memories ordered chronologically. Default (important_only=false) includes all memories ordered by COALESCE(occurred_at, created_at) ASC. Set important_only=true to return only memories with occurred_at set (the curated decision timeline). Pass memory_id instead of domain to scope the timeline to a single memory's neighbourhood (depth 2 by default, domain-clipped) — useful for understanding how a specific workstream evolved. memory_id takes precedence if both domain and memory_id are supplied. Optional from/to date filters apply to the effective date. Optional tags filter uses whole-word matching. Optional node_kind filter (space-separated union) restricts timeline entries to matching kinds. For importance analysis beyond the timeline, use significance. Returns lean results only — id, label, and a truncated why_matters excerpt; call recall(id) for full content. When a list or section has 2 or more results, each is rendered as a single compact text line — "[id] label — excerpt (domain, node_kind)" — instead of a JSON object; exactly one result is returned as a full object. Each line also carries the memory's effective date.

  ConnectorAPI key

• visualiseA

  recordariA

  Generate a Mermaid.js flowchart for human visual inspection only. NOT for orphan detection or programmatic analysis — use audit(mode=orphans) to find isolated memories. Output may be truncated for large domains; never infer graph properties (e.g. orphans) from a truncated result. Pass memory_id (memory ID) to see a single memory and all its direct connections. Pass domain to see the full domain graph (most-connected memories first, capped at limit, default 40 max 100). Returns JSON with mermaid, node_count, edge_count, nodes_shown, nodes_total, edges_shown, edges_total, truncated, memories([{id,label}]) and connections([{from,to,relationship}]). If client supports HTML widgets, prefer passing memories and connections to an interactive renderer rather than outputting raw mermaid. If not, output mermaid inside a ```mermaid code block. If truncated is true, note only most-connected memories are shown and nodes_total/edges_total reveal what was dropped.

  ConnectorAPI key

• get_sc_theoryA

  SCModelingA

  Reference guide to supply-chain simulation concepts: ordering policies, BOM, FDD formulas, event-driven simulation. Pure static text — no engine call, deterministic output. Use this when the user asks a conceptual 'how does this work' question rather than asking for a number.

  ConnectorNo auth

• delete_memoriesA

  MemoryRouterA

  Use this only when the user explicitly asks to delete specific memories and confirms after seeing what will be deleted. Permanently deletes the identified memories from the connected vault by their ids from search or inspect results. Deleting a raw memory does not delete reflections built from it. This cannot be undone. For deleting everything, forget_all_memories is the separate whole-vault tool.

  Connector

  Destructive

  No auth

• forgetA

  recordariA

  Archive (soft-delete), un-archive, or permanently purge one or more memories. ARCHIVE (default): Only call after explicit unambiguous user confirmation — never on implication or casual mention. If archiving multiple memories, prefer the items array — the same confirmation protocol applies. Single archive: {id, reason}. Batch archive — use this when you have 2 or more confirmed memories to archive at once; more efficient than multiple single calls: {items:[{id,reason},...]} — returns {results:[{id,success,error}]}. RESTORE: Pass restore=true to un-archive an archived memory — obtain the ID from audit(mode=archived). Same explicit confirmation gate as archive. Single restore: {id, restore:true}. Batch restore: {items:[{id},...], restore:true}. PURGE (hard delete): Pass purge=true to permanently delete an already-archived memory and all its connections. Purge only operates on archived memories — archive the memory first if it is still live. A workspace key can only purge memories with no live inbound connections; connected memories return a structured warning listing live_inbound_connections rather than an error, and are not purged. Pass force=true (org_admin or platform key only) to override the connection guard and purge regardless. A workspace key passing force=true is rejected with error_class=forbidden. Single purge: {id, purge:true} or {id, purge:true, force:true}. Batch purge: {items:[{id},...], purge:true} — returns {results:[{id,purged,warning,error}]}. On failure, content[0].text is JSON: {"error_class": "not_found|retryable|forbidden|validation|internal", "message": "..."}. Switch on error_class: retry on retryable.

  Connector

  Destructive

  API key

• significanceA

  recordariA

  Dual-signal importance analysis. Returns four sections, each capped at limit (default 10) and paired with a boolean *_results_truncated signal (declared_results_truncated, structural_results_truncated, uncurated_results_truncated, potentially_stale_results_truncated) — true when that section's count equals limit and more may exist. Call again with a higher limit to get more of the same ranked/ordered list, not a different one: - declared: memories explicitly marked significant (occurred_at set), most-recent-limit, chronological ascending. - structural: memories ranked by weighted inbound degree — SUM(1/(1+days_since_linker_updated)), top-limit. High score means many recently-active memories depend on this memory right now. Linkers updated more than recency_window days ago contribute zero weight. - uncurated: memories in structural top-N with no occurred_at — significance candidates not yet on the timeline. Its results_truncated mirrors structural's, since it is a filter over that same section. - potentially_stale: memories with occurred_at that do not appear in structural top-N — declared important but nothing current depends on them. Its results_truncated mirrors declared's, since it is a filter over that same section. Pass memory_id to scope significance to a single memory's neighbourhood (depth 2, domain-clipped) — useful for workstream health checks when you already know the anchor. Pass domain for a full domain scan. memory_id takes precedence if both are supplied. Optional node_kind (space-separated union) filters all sections to matching kinds. The gap between uncurated and potentially_stale is the most actionable output: use it to promote missed decisions onto the timeline and archive claims that no longer hold. Do not use this tool to list all memories chronologically — use history for that. For age-based staleness, use audit(mode=stale). significance and audit are complementary: significance catches importance-based staleness; audit catches age-based staleness. Pass mode=trust for epistemic trust ranking instead of dual-signal analysis. Trust mode returns memories ranked by trust_score [0,1] with trust_basis per memory — derived from node_kind intrinsic weight plus inbound neighbour contributions (contradicts connections subtract). When node_kind is omitted, reference and transient memories are excluded from trust output; when node_kind is set, only matching kinds are returned. nodes_results_truncated is true when more ranked memories exist beyond limit. Returns lean results only — id, label, and a truncated why_matters excerpt; call recall(id) for full content. When a list or section has 2 or more results, each is rendered as a single compact text line — "[id] label — excerpt (domain, node_kind)" — instead of a JSON object; exactly one result is returned as a full object. structural/uncurated digest lines also carry the importance_score; trust mode digest lines carry trust_score and trust_basis.

  ConnectorAPI key

• particle_podcast_list_relatedA

  particle-proA

  List the shows most related to a podcast, best first — "shows like this show". Each result carries the related show's slug, a calibrated score in (0,1], and a coarse band (strong: same beat and audience; moderate: overlapping subject or audience; weak: a loose connection) to branch on. Add `include: ["basis"]` to see WHY each pair is related: content similarity of recent episodes, shared topics, shared guests (named), same publisher, shared sponsors — use it to explain a recommendation or to keep only pairs related for the reason you care about (shared guests for booking, content for media planning). Related sets are precomputed per show from its transcripts, topic profile, guest roster, network and advertisers, restricted to the show's language. Only shows above a relatedness floor are listed, machine-generated and farmed feeds are never listed, and a publisher's duplicate feeds of one show appear once. An empty FIRST page is not an error: its `coverage` says whether the set is not computed yet, nothing cleared the floor, or the request's filters and the default policy removed everything; an empty page reached through a cursor is simply the end of the list. Not a topic browser: for shows that COVER a topic use `particle_podcast_resolve` with `topic_slug`. Not a guest lookup: for where a person has appeared use `particle_podcast_get_guest`. Not advertiser co-occurrence: use `particle_podcast_get_sponsors`. Every related show's slug feeds `particle_podcast_resolve`, `particle_podcast_list_episodes` and the other podcast tools; person slugs in the basis feed `particle_podcast_get_guest`, topic slugs feed `particle_podcast_resolve`'s `topic_slug`. For the five most related shows inline on a resolve, pass `include: ["related"]` to `particle_podcast_resolve` instead of calling this tool.

  ConnectorOAuth

• list_memoriesA

  memxusA

  List recent memories in reverse-chronological order (read-only). When to use: audit what is saved, browse a collection, or collect memory IDs for get_memory or forget. When NOT: semantic search by topic → recall; one full record → get_memory; aggregate counts only → memory_stats. Behavior: default 20 results (plan-capped), ordered by created_at descending; empty set returns a message suggesting remember; full_content controls preview in the message text (120 chars); structured memories[] always includes full content. To list a team workspace instead of personal memory, pass workspace: <name>.

  ConnectorNo auth

• searchA

  recordariA

  Search memories by keyword. The query must use vocabulary that appears in stored labels, descriptions, or tags — not intent summaries or paraphrases. Pass node_kind (space-separated) to list or search within specific kinds — unrelated kinds that happen to match query text are excluded. Omit query with node_kind set to list matching kinds ordered by most-recently-updated. Default limit: 10. Use exact=true for identifiers (ticket numbers, short codes with hyphens) — FTS tokenises hyphens away so 'PROJ-042' is not found by default. If search returns zero or truncated results, use orient (with domain) to browse all memories, then recall by ID, then follow connections from a known memory. Returns lean results only — id, label, and a truncated why_matters excerpt; call recall(id) for full content. When a list or section has 2 or more results, each is rendered as a single compact text line — "[id] label — excerpt (domain, node_kind)" — instead of a JSON object; exactly one result is returned as a full object. exact=true is exempt — it always returns full objects, regardless of result count. state (space-separated union) post-filters results to memories with any of the given lifecycle states: none | resolved | superseded | contested. On failure, content[0].text is JSON: {"error_class": "retryable|forbidden|internal", "message": "..."}. Switch on error_class: retry on retryable.

  ConnectorAPI key

• gripforge_generation_readA

  GripForgeB

  Poll a job returned by a generation tool. Includes durable steps, progress, failure/retry state and the resulting work revision with a Studio link. include_preview returns the saved image or all map concept views (at most 4). Set preview_view to return one chosen concept view. Concepts are generated illustrations, not implemented-map renders. Success does not mean visual approval or promotion.

  ConnectorNo auth

• connectA

  Penfield MemoryA

  Connect memories to build knowledge graphs. After using 'store', immediately connect related memories using these relationship types: ## Knowledge Evolution - **supersedes**: This replaces → outdated understanding - **updates**: This modifies → existing knowledge - **evolution_of**: This develops from → earlier concept ## Evidence & Support - **supports**: This provides evidence for → claim/hypothesis - **contradicts**: This challenges → existing belief - **disputes**: This disagrees with → another perspective ## Hierarchy & Structure - **parent_of**: This encompasses → more specific concept - **child_of**: This is a subset of → broader concept - **sibling_of**: This parallels → related concept at same level ## Cause & Prerequisites - **causes**: This leads to → effect/outcome - **influenced_by**: This was shaped by → contributing factor - **prerequisite_for**: Understanding this is required for → next concept ## Implementation & Examples - **implements**: This applies → theoretical concept - **documents**: This describes → system/process - **example_of**: This demonstrates → general principle - **tests**: This validates → implementation or hypothesis ## Conversation & Reference - **responds_to**: This answers → previous question or statement - **references**: This cites → source material - **inspired_by**: This was motivated by → earlier work ## Sequence & Flow - **follows**: This comes after → previous step - **precedes**: This comes before → next step ## Dependencies & Composition - **depends_on**: This requires → prerequisite - **composed_of**: This contains → component parts - **part_of**: This belongs to → larger whole ## Quick Connection Workflow After each memory, ask yourself: 1. What previous memory does this update or contradict? → `supersedes` or `contradicts` 2. What evidence does this provide? → `supports` or `disputes` 3. What caused this or what will it cause? → `influenced_by` or `causes` 4. What concrete example is this? → `example_of` or `implements` 5. What sequence is this part of? → `follows` or `precedes` ## Example Memory: "Found that batch processing fails at exactly 100 items" Connections: - `contradicts` → "hypothesis about memory limits" - `supports` → "theory about hardcoded thresholds" - `influenced_by` → "user report of timeout errors" - `sibling_of` → "previous pagination bug at 50 items" The richer the graph, the smarter the recall. No orphan memories! Args: from_memory: Source memory UUID to_memory: Target memory UUID relationship_type: Type from the categories above strength: Connection strength (0.0-1.0, default 0.5) ctx: MCP context (automatically provided) Returns: Dict with success status, relationship_id, and connected memory IDs

  ConnectorOAuth

• reflectA

  Penfield MemoryA

  Reflect on recent thoughts and patterns. Analyzes recent activity to identify patterns, topics, and insights. Useful for understanding "what have I been thinking about?" By default, only returns user-created memories (not document chunks). Set include_documents=True to also include chunks from uploaded documents. ⚠️ EXPERIMENTAL: - Importance weighting in results not yet implemented. Importance scores are stored but don't affect ranking. Args: time_window: Time period to analyze ('recent', 'today', 'week', 'month', '1d', '7d', '30d', '90d') include_documents: Whether to include document chunks (default: False, only user memories) start_date: Filter memories created on or after this date (ISO 8601: '2025-01-01' or '2025-01-01T00:00:00Z') end_date: Filter memories created on or before this date (ISO 8601: '2025-01-09' or '2025-01-09T23:59:59Z') ctx: MCP context (automatically provided) Returns: Dict with analysis including top memories, active topics, patterns, insights, and any saved contexts (checkpoints) created in the window. Examples: >>> await reflect("recent") {'success': True, 'memories_analyzed': 50, 'active_topics': [...], 'contexts': [...], ...} >>> await reflect("week", include_documents=True) {'success': True, 'memories_analyzed': 150, ...} # includes document chunks >>> await reflect(start_date="2025-01-01", end_date="2025-01-07") {'success': True, 'memories_analyzed': 25, ...} # memories from first week of January

  ConnectorOAuth

• x711_vault_compressA

  x711A

  Groq-powered vault compression: 50 cold (least-read) memories → 5 dense summaries. Source memories are archived after compression. Net result: sharper vault, lower LLM token cost when injecting context. Automatically refunded if Groq fails. $0.05. Requires API key.

  ConnectorNo auth

• secedgar_compare_companiesA

  secedgar-mcp-serverA

  Compare 2-10 named companies across 1-8 XBRL concepts, aligned on calendar periods. This is the middle shape between secedgar_get_financials (one company, one concept, full history) and secedgar_fetch_frames (one concept, one period, every reporting company) — reach for it when the question names the companies. One companyfacts read per company, resolved through the same frame dedup and tag priority as secedgar_get_financials so the numbers agree. Balance-sheet and entity-info concepts are filed as point-in-time values and align on the calendar year (annual) or quarter (quarterly) their snapshot falls in, so they sit in the same matrix as income-statement lines. The inline matrix covers the most recent periods up to `periods`, trimmed further when companies x concepts x periods is too large to return in one response; the full aligned series is materialized as df_<id> for growth rates and spreads — inspect it with secedgar_dataframe_describe, then analyze it with secedgar_dataframe_query. A company that fails to resolve is reported in failed_companies and the comparison proceeds with the rest, and a company that does not report a concept is reported in gaps with the tags that were tried — never interpolated or zero-filled. Off-calendar filers and unit mismatches are surfaced in caveats rather than silently mixed.

  ConnectorNo auth

• x711_vault_compressA

  x711 — Universal Agent Gas StationB

  Groq-powered vault compression: 50 cold (least-read) memories → 5 dense summaries. Source memories are archived after compression. Net result: sharper vault, lower LLM token cost when injecting context. Automatically refunded if Groq fails. $0.05. Requires API key.

  ConnectorNo auth

• gribstream_resolve_shared_parameterA

  GribStream Weather MCPA

  NO AUTH / PUBLIC / READ-ONLY. Resolves one shared parameter preset for a dataset, returning native variables and expressions to use in /timeseries or /runs request bodies. Use this first for common natural-language concepts such as 2 metre temperature or 10 metre wind instead of guessing dataset-native codes such as TMP. This tool does not execute the request, query weather values, or return forecast data.

  ConnectorNo auth

• cortex_recallA

  CortexA

  Use this when the user asks about a topic as a whole ("what do you know about X", "where are we with X", "catch me up on X"): returns one narrative synthesis of the relevant memories, saying what holds now and what was superseded. Do not use it to look up a single fact or when you need sources to cite: search returns individual memories with their urls.

  ConnectorNo auth

• list_capabilitiesA

  Cito APIA

  Curated catalog of cito-mcp tools, games, jobs, and builder recipes. When to use: - Session start or "what can you do?" - Mapping app screens to tools - Filtering by game or job (live_board, match_page, team_page, player_form, standings, h2h, schedule, preview, event_card, app_scaffold) Prefer over: guessing from memory; exploring raw OpenAPI via call_api. Do not use when: you already know the tool and have IDs — call that tool directly. Parallel-safe: yes. Upstream cost: 0. Example: { "game": "cs2", "job": "live_board", "includeExamples": true }

  ConnectorNo auth

• delete_all_memoriesA

  MemorySyncA

  Delete all memories this connection can reach. Defaults to a dry run that reports the count only; deleting for real requires dry_run=false and the exact confirm string 'DELETE ALL MEMORIES'. Never call this without the user explicitly asking to erase everything.

  Connector

  Destructive

  OAuth

• memory_feedbackA

  Mnemoverse MemoryA

  Rate personal-scope memories returned by memory_read — outcome from -1.0 (unhelpful) to +1.0 (helpful) — to improve future ranking. Shared-room IDs are not supported because this tool has no domain input. Changes ranking signals only; never alters or deletes the saved text.

  ConnectorOAuth

• autonomous_varrd_aiA

  VARRD — Statistically Validated Trading Edges + AI Research EngineA

  Point VARRD's autonomous AI in a direction and let it discover edges for you. Give it a topic and it draws from one of the most comprehensive market structure knowledge graphs ever built — containing ideologies and theories, not statistics — so it generates genuinely novel hypotheses rather than overfitting to what already worked. BEST FOR: Exploring a space broadly. Give it 'momentum on grains' and it might test wheat seasonal patterns, corn spread reversals, or soybean crush ratio momentum. It propagates from your seed idea into related concepts you might not think of. Returns a complete result — edge or no edge, stats, trade setup. Each call tests ONE hypothesis through the full pipeline (~$0.25/idea). Call again for another idea. Use 'varrd_ai' instead when YOU have a specific idea to test and want full control over each step.

  ConnectorNo auth