Server definition

Hash: sha256:071c042d9c3477daac06097a0d095aaf519793ebc519237ea74fd3cd995254b5
What it is: What a remote MCP server returned when asked what it offers: 6 tools

The blob, as servednamed by its sha256

{
  "instructions": null,
  "tools": [
    {
      "description": "Soft-delete a memory by id. The row is retained for audit but excluded from search/list and removed from the vector index.",
      "inputSchema": {
        "properties": {
          "id": {
            "description": "UUID of the memory to forget.",
            "type": "string"
          }
        },
        "required": [
          "id"
        ],
        "type": "object"
      },
      "name": "memory_forget",
      "outputSchema": null
    },
    {
      "description": "List the user's most recent memories in reverse chronological order. Use for browsing or catching up on what the user's other model sessions have written recently. Same content/content_raw shape as memory_search. Optional filters (tags, written_by, session_id, since, until) narrow the listing at the SQL level.",
      "inputSchema": {
        "properties": {
          "cursor": {
            "description": "Pagination cursor from a previous call's `cursor` field (ms epoch); returns rows older than this timestamp.",
            "type": "integer"
          },
          "limit": {
            "description": "Max rows to return (1–200). Default 50.",
            "type": "integer"
          },
          "raw": {
            "description": "Return original prose instead of the compressed form. Default false.",
            "type": "boolean"
          },
          "session_id": {
            "description": "Only return memories with an exact session_id match.",
            "type": "string"
          },
          "since": {
            "description": "Only return memories created at or after this ms-epoch timestamp.",
            "type": "integer"
          },
          "tags": {
            "description": "Only return memories containing ALL of these tags (AND semantics).",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "until": {
            "description": "Only return memories created strictly before this ms-epoch timestamp.",
            "type": "integer"
          },
          "written_by": {
            "description": "Only return memories with an exact written_by match.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "name": "memory_list",
      "outputSchema": null
    },
    {
      "description": "Search the user's memories. Default mode is 'hybrid': blends semantic (cosine over Vectorize) and keyword (BM25 over SQLite FTS5) hits via Reciprocal Rank Fusion (k=60). Semantic catches paraphrases; keyword catches exact-string hits (IDs, dates, code snippets). Pass mode:'semantic' or mode:'keyword' to run just one. Content defaults to the LLM-optimized (compressed) form when available (raw:true to invert). Excludes forgotten + superseded. Optional filters narrow after retrieval: tags (AND), written_by, session_id, and/or since/until (ms epoch).",
      "inputSchema": {
        "properties": {
          "k": {
            "description": "Max results (1–50). Default 10.",
            "type": "integer"
          },
          "mode": {
            "description": "Retrieval mode. Default 'hybrid'.",
            "enum": [
              "semantic",
              "keyword",
              "hybrid"
            ],
            "type": "string"
          },
          "query": {
            "description": "Search query. Interpreted as natural language for semantic mode and as FTS5-safe text for keyword mode.",
            "type": "string"
          },
          "raw": {
            "description": "Return original prose instead of the compressed form. Default false.",
            "type": "boolean"
          },
          "session_id": {
            "description": "Only return memories with an exact session_id match.",
            "type": "string"
          },
          "since": {
            "description": "Only return memories created at or after this ms-epoch timestamp.",
            "type": "integer"
          },
          "tags": {
            "description": "Only return memories containing ALL of these tags (AND semantics).",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "until": {
            "description": "Only return memories created strictly before this ms-epoch timestamp.",
            "type": "integer"
          },
          "written_by": {
            "description": "Only return memories with an exact written_by match (e.g. 'claude-code').",
            "type": "string"
          }
        },
        "required": [
          "query"
        ],
        "type": "object"
      },
      "name": "memory_search",
      "outputSchema": null
    },
    {
      "description": "Replace a stale memory with a corrected one. The old row is marked superseded and excluded from future reads; the new row becomes the current version. Use for corrections; use memory_forget for pure deletions.",
      "inputSchema": {
        "properties": {
          "new_content": {
            "description": "New content that supersedes the old memory.",
            "type": "string"
          },
          "old_id": {
            "description": "UUID of the memory to replace.",
            "type": "string"
          },
          "session_id": {
            "type": "string"
          },
          "tags": {
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "written_by": {
            "type": "string"
          }
        },
        "required": [
          "old_id",
          "new_content"
        ],
        "type": "object"
      },
      "name": "memory_supersede",
      "outputSchema": null
    },
    {
      "description": "Save a fact, preference, decision, or note to the user's cross-model memory. Any MCP client can read this back later. Include written_by (e.g. 'claude-code', 'gpt-5', 'kimi-k2') for provenance and session_id to group related writes. Long content (>400 chars) is automatically compressed on write to a structured-facts form optimized for LLM reading — the raw text is preserved. Pass no_optimize:true to skip. Writes are deduped by default: (1) SHA-256 of trim(content) short-circuits byte-identical writes with { id, exact_duplicate:true } for free (no embed call); (2) failing that, semantic dedup returns { id, deduped:true, matched_score } when cosine ≥ 0.85. Pass force:true to bypass both, or use memory_supersede to explicitly correct a prior memory.",
      "inputSchema": {
        "properties": {
          "content": {
            "description": "The fact or note to remember. Plain text, max 8000 characters.",
            "type": "string"
          },
          "force": {
            "description": "Bypass semantic dedup and write anyway. Default false.",
            "type": "boolean"
          },
          "no_optimize": {
            "description": "Skip AI compression of long content. Default false.",
            "type": "boolean"
          },
          "session_id": {
            "description": "Opaque identifier grouping related writes from the same conversation.",
            "type": "string"
          },
          "tags": {
            "description": "Optional short labels for filtering (e.g. ['preference','stack']).",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "written_by": {
            "description": "Identifier of the model / client writing this (e.g. 'claude-code', 'gpt-5', 'kimi-k2', 'manual').",
            "type": "string"
          }
        },
        "required": [
          "content"
        ],
        "type": "object"
      },
      "name": "memory_write",
      "outputSchema": null
    },
    {
      "description": "Write up to 50 memories in a single call. Each entry runs the same path as memory_write (semantic dedup by default; pass force:true per-entry to skip). Embeddings + optimizations run in parallel; D1 inserts are batched. Returns { results: [...] } with one entry per input in the same order — each is { id, created_at, optimized? } on success, { id, created_at, deduped, matched_score } on dedup, or { error } on failure. Free-tier limits apply to the sum: if adding N would exceed 200, the first (200 - existing) succeed and the rest return an error.",
      "inputSchema": {
        "properties": {
          "memories": {
            "description": "Array of memory-write entries (1–50).",
            "items": {
              "properties": {
                "content": {
                  "description": "The fact or note to remember. Plain text, max 8000 characters.",
                  "type": "string"
                },
                "force": {
                  "description": "Bypass semantic dedup for this entry. Default false.",
                  "type": "boolean"
                },
                "no_optimize": {
                  "description": "Skip AI compression of long content. Default false.",
                  "type": "boolean"
                },
                "session_id": {
                  "type": "string"
                },
                "tags": {
                  "items": {
                    "type": "string"
                  },
                  "type": "array"
                },
                "written_by": {
                  "type": "string"
                }
              },
              "required": [
                "content"
              ],
              "type": "object"
            },
            "maxItems": 50,
            "minItems": 1,
            "type": "array"
          }
        },
        "required": [
          "memories"
        ],
        "type": "object"
      },
      "name": "memory_write_bulk",
      "outputSchema": null
    }
  ]
}

Verify it yourself

curl -s https://api.teppi.xyz/v1/evidence/sha256:071c042d9c3477daac06097a0d095aaf519793ebc519237ea74fd3cd995254b5 | sha256sum