Server definition

Hash: sha256:1400eca467ec50cb67179c709a5bce7d5794eec9e4d8005fe8deb98743019399
What it is: What a remote MCP server returned when asked what it offers: 11 tools

The blob, as servednamed by its sha256

{
  "instructions": null,
  "tools": [
    {
      "description": "Create and/or update many elements across any of the 22 types in one call.\n\nEach entry in `items` is `{\"type\": <slug>, \"element\": <payload>}` with the same\npayload shape `create_element` takes: an `element` with an `id` UPDATES that id\n(creating it if absent), an `element` without an `id` CREATES a new element.\nItems may reference each other by id, including a forward reference to a sibling\nlater in the list. There is NO delete: bulk_apply never removes an element.\nWhen `atomic` is false (default), items succeed or fail independently and the\nresponse reports each outcome; when `atomic` is true, ANY item failure rolls the\nwhole batch back and nothing is committed. Up to 1000 items. Requires a WRITE\nAPI-Key. Returns the batch response verbatim: `{errors, items: [{status, id,\ncreated_at, updated_at} | {status, id, error}, ...]}` — `errors` true means at\nleast one item failed (and, under `atomic`, that nothing committed).",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "atomic": {
            "default": false,
            "type": "boolean"
          },
          "items": {
            "items": {},
            "type": "array"
          }
        },
        "required": [
          "items"
        ],
        "type": "object"
      },
      "name": "bulk_apply",
      "outputSchema": {
        "additionalProperties": true,
        "type": "object"
      }
    },
    {
      "description": "Create one new element of `type` in the world named by your API-Key header.\n\n`type` is a slug from `list_element_types` (e.g. \"character\"). `element` is the\nfield payload: `name` plus any scalar, link, or extension fields for that type\n(call `get_element_schema(type)` for the field structure). Link fields are UUID\narrays (multi) or a single UUID (single); every linked id must already exist in\nthe world. Supply your own `id` (a UUID) to mint the element at that id, or omit\n`id` and the server mints a uuid7. Requires a WRITE API-Key. Returns the full\ncreated element in the v2 wire shape. Errors (naming the offending field) on an\nunknown field, a bad link target, or an id that already exists.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "element": {
            "additionalProperties": true,
            "type": "object"
          },
          "type": {
            "type": "string"
          }
        },
        "required": [
          "type",
          "element"
        ],
        "type": "object"
      },
      "name": "create_element",
      "outputSchema": {
        "additionalProperties": true,
        "type": "object"
      }
    },
    {
      "description": "Add and/or remove links on ONE multi-link `field` of an element, leaving the\nrest of that field's array untouched.\n\nUse this for additive/subtractive link edits (unlike `update_element`, which\nREPLACES a link array). `type` is a slug from `list_element_types`; `id` is the\nelement's UUID; `field` must be a multi-link field on that type (see\n`get_element_schema(type)`). `add` is a list of UUIDs to link (each must already\nexist in the world; adding an already-linked id is a no-op) and `remove` is a\nlist of UUIDs to unlink (removing an absent id is tolerated). Requires a WRITE\nAPI-Key. Returns `{type, id, field, values}` where `values` is the field's full\nUUID array after the edit. Errors (naming `field`) if it is not a multi-link\nfield of this type, if the element does not exist, or if an added target id is\nabsent.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "add": {
            "anyOf": [
              {
                "items": {},
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "default": null
          },
          "field": {
            "type": "string"
          },
          "id": {
            "type": "string"
          },
          "remove": {
            "anyOf": [
              {
                "items": {},
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "default": null
          },
          "type": {
            "type": "string"
          }
        },
        "required": [
          "type",
          "id",
          "field"
        ],
        "type": "object"
      },
      "name": "edit_links",
      "outputSchema": {
        "additionalProperties": true,
        "type": "object"
      }
    },
    {
      "description": "Return the delta feed for the world named by your API-Key header: every\nelement created/updated (`op: \"upsert\"`, full body) or deleted (`op:\n\"delete\"`) since `since_cursor`, in apply order, in pages of `limit`\n(default 25, max 1000). Entries carry FULL element bodies — a default page\nstays inside any client's token budget; measured worlds ran ~1.5-2k chars\nPER ENTRY, so raise `limit` only if you truly need bigger pages, and prefer\npaging with the cursor.\n\nOmit `since_cursor` (or pass \"\") to start from the beginning of the feed —\nfor a big world that is a multi-page walk, not one response. Pass the\nreturned `cursor` back as `since_cursor` to get the next page (or, later,\nonly what changed since); treat the cursor as OPAQUE. `has_more` true means\npage again with the new cursor. Requires a READ or WRITE API-Key. This\nmirrors `GET /api/v2/changes`.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "limit": {
            "default": 25,
            "type": "integer"
          },
          "since_cursor": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null
          }
        },
        "type": "object"
      },
      "name": "get_changes",
      "outputSchema": {
        "additionalProperties": true,
        "type": "object"
      }
    },
    {
      "description": "Fetch one element by `type` and `id` (a UUID) from the world named by your\nAPI-Key header.\n\n`type` is a slug from `list_element_types`. Returns the full v2 wire shape\n(the same body as `GET /api/v2/{type}/{id}`): `type`, `id`, `name`, scalar\nfields, link fields as UUID arrays, and any extension fields inline. Requires a\nREAD or WRITE API-Key. Errors if no element of that type with that id exists in\nthe world.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "id": {
            "type": "string"
          },
          "type": {
            "type": "string"
          }
        },
        "required": [
          "type",
          "id"
        ],
        "type": "object"
      },
      "name": "get_element",
      "outputSchema": {
        "additionalProperties": true,
        "type": "object"
      }
    },
    {
      "description": "Return the field structure of one OnlyWorlds element `type` (a slug from\n`list_element_types`, e.g. \"character\").\n\nThe result groups the type's writable fields by kind so a caller knows how to\nread and write them: `text` (strings), `integer`, `single_link` (one UUID),\n`multi_link` (an array of UUIDs), and `generic` (a type+id pair pointing at any\nelement type). For every link field the target element type is given under\n`link_targets`. All link values are element UUIDs. Unauthenticated. Errors if\n`type` is not one of the 22 types.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "type": {
            "type": "string"
          }
        },
        "required": [
          "type"
        ],
        "type": "object"
      },
      "name": "get_element_schema",
      "outputSchema": {
        "additionalProperties": true,
        "type": "object"
      }
    },
    {
      "description": "List all 22 OnlyWorlds element types with a one-line shape summary of each.\n\nEvery world is built from these types; each element has a stable UUID `id`, a\n`name`, and a `type`. Use `get_element_schema(type)` for a type's full field\nlist. Unauthenticated — schema is public reference. Returns a mapping of the 22\ntype slugs (the value you pass as `type` to the data tools) to a summary\nstring.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {},
        "type": "object"
      },
      "name": "list_element_types",
      "outputSchema": {
        "additionalProperties": true,
        "type": "object"
      }
    },
    {
      "description": "List elements of one `type` in the world named by your API-Key header,\nnewest-created first.\n\n`type` is a slug from `list_element_types` (e.g. \"character\"). Optional\n`name_contains` filters by case-insensitive name substring; `supertype`\nfilters exactly. `limit` (default 100, max 1000) and `offset` page the result.\nRequires a READ or WRITE API-Key. Returns `{data: [element, ...], limit,\noffset, has_more}` where each element is the full v2 wire shape and `id` is a\nUUID. Use `get_element(type, id)` for a single element.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "limit": {
            "default": 100,
            "type": "integer"
          },
          "name_contains": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null
          },
          "offset": {
            "default": 0,
            "type": "integer"
          },
          "supertype": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null
          },
          "type": {
            "type": "string"
          }
        },
        "required": [
          "type"
        ],
        "type": "object"
      },
      "name": "list_elements",
      "outputSchema": {
        "additionalProperties": true,
        "type": "object"
      }
    },
    {
      "description": "Search elements by name across ALL 22 types in the world named by your\nAPI-Key header (case-insensitive substring match).\n\nUse this when you know part of a name but not the element's type. Bounded to at\nmost 50 matches per type. Returns `{query, results: [{type, id, name,\nsupertype, subtype}, ...]}` — `id` is a UUID; call `get_element(type, id)` for\nthe full body. Requires a READ or WRITE API-Key.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "query": {
            "type": "string"
          }
        },
        "required": [
          "query"
        ],
        "type": "object"
      },
      "name": "search_elements",
      "outputSchema": {
        "additionalProperties": true,
        "type": "object"
      }
    },
    {
      "description": "Search every element type's fields for `query` (case-insensitive substring),\nacross all 22 types. Useful for \"which types have a `location` field?\" or\nfinding where a concept lives in the schema.\n\nReturns a mapping of type slug -> the matching field names in that type (types\nwith no match are omitted); a `query` that also matches a type slug lists that\ntype with an empty field list so the type-name hit is not lost. Unauthenticated.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "query": {
            "type": "string"
          }
        },
        "required": [
          "query"
        ],
        "type": "object"
      },
      "name": "search_schema",
      "outputSchema": {
        "additionalProperties": true,
        "type": "object"
      }
    },
    {
      "description": "Update an existing element by `type` and `id`, changing ONLY the fields you\npass — omitted fields are preserved.\n\nThis is a server-side read-merge: the current element is loaded and only the\nkeys in `fields` are applied, so it is safe against the raw-HTTP-PATCH hazard\nwhere sending a partial link array replaces the whole array. Semantics per field\nkind: a text field you pass is set (pass an empty string `\"\"` to clear it); a\nmulti-link field you pass REPLACES that field's array wholesale (pass an empty\narray `[]` to clear it) — for additive/subtractive link edits that leave the\nrest of the array intact, use `edit_links` instead. `type` is a slug from\n`list_element_types`; `id` is the element's UUID. Requires a WRITE API-Key.\nReturns the full updated element in the v2 wire shape. Errors if the element\ndoes not exist, or (naming the field) on an unknown field or a bad link target.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "fields": {
            "additionalProperties": true,
            "type": "object"
          },
          "id": {
            "type": "string"
          },
          "type": {
            "type": "string"
          }
        },
        "required": [
          "type",
          "id",
          "fields"
        ],
        "type": "object"
      },
      "name": "update_element",
      "outputSchema": {
        "additionalProperties": true,
        "type": "object"
      }
    }
  ]
}

Verify it yourself

curl -s https://api.teppi.xyz/v1/evidence/sha256:1400eca467ec50cb67179c709a5bce7d5794eec9e4d8005fe8deb98743019399 | sha256sum