Orbismo

Call this before any other tool in a world. Single bootstrap tool returning the complete world vocabulary: entity types with property schemas, valid relationship types (with their allowed source/target entity types, inverse labels and property schemas), semantic predicates, and enumeration dictionaries (for each enumerable property, the values entities currently use — descriptive and advisory, not a closed set of allowed values). Call once at session start before any create, search, or query tool — without it you will not know what entity and relationship types are valid. Set include_stats to also get entity counts by type and recently updated entities. This is the machine-readable schema/vocabulary; for the creator-authored prose rules and style for this world, call get_world_instructions.

get_world_context

Returns the world creator's written requirements and preferences for work in the target world, such as conventions, style, constraints, and lore. This is free-form, user-authored text, returned as written. Useful before working in a world, and again if the instructions may have changed. For the machine-readable entity/relationship schema and vocabulary, call get_world_context.

get_world_instructions

Start here. Lists the worlds the user can reach, granted worlds first, with the current default (the one chosen with set_active_world) at the top. Each entry carries world_id, name, entity_count, a description when the creator wrote one, the current_role the user holds, and in_grant: only in-grant worlds can be operated on. If it is not clear which world the user means and more than one is in grant, ask once rather than guess, then pass that world_id on each call or choose it once with set_active_world. Entries outside the grant carry a grant_url the user can open to add the world, or grant_url_unavailable_reason when a link cannot be minted right now. Returns up to 50 entries per call plus total_count; pass next_cursor to page. Optional filter: { in_grant_only: bool, search: substring }.

list_my_worlds

Query the relationship graph. `mode: "edges"` returns relationships filtered by source/target/type with cursor pagination. `mode: "neighbors"` returns the entity's relationship neighbourhood up to depth N (1-3 hops) — `entity_id` is REQUIRED in this mode. Both modes default to active_only: true (excludes ended relationships); set active_only: false to include historical edges. Mode-irrelevant fields are ignored at the handler.

query_relationships

Search/list entities or aggregate tags. `return: "entities"` (default): paginated hits `{ returned_count, results, next_cursor }`; no filters = list all. `query` is hybrid: fuzzy name match (typo-tolerant) plus semantic match on short_descriptions — for concept queries a descriptive phrase beats keywords. Lore is not searched here (use search_lore). Hits carry `match_type` ("name" | "semantic" | "both") and `relevance_score` on per-type scales: name exact ≈ 1.0, floor 0.2, near-floor = noise; semantic floor 0.45, 0.45–0.6 already strong. Zero hits = neither path matched. `search_mode: "name"` disables the semantic arm; response field `semantic_search` reports "ok" | "indexing" (retry shortly) | "partial" | "unavailable". `filter`: one predicate on entity properties; `tags`: tag membership. `view`: "compact" = `{entity_id, name, entity_type}`, "summary" (default) adds a `preview`; cursors survive view changes but not search_mode changes (rejected as stale). Full detail: get_entities. `return: "tags"`: `{ tags: [{tag, count}], total_unique, next_cursor }` (case-sensitive; `filter` ignored; ≤500/page). Mode-irrelevant fields are ignored.

search_entities

Semantic search over lore content using natural language. Finds lore chunks most relevant to your query across all entities (or scoped to a specific entity/type). Returns ranked results with `similarity_score` on a lore-specific scale: floor 0.2 (weaker matches are not returned), ~0.25–0.45 a solid topical hit, ≥0.5 strong, near-verbatim ~0.8 — lore scores run lower than search_entities relevance_score, so do not discard mid-0.3 hits as weak. Fewer hits than `limit` (or zero) means nothing else cleared the floor. Response field `semantic_search` reports "ok" | "indexing" (chunks still vectorizing — retry shortly) | "partial" (some chunks unsearchable) | "no_lore" (world has no lore). Entity short_descriptions often summarize lore, so results can overlap search_entities — use search_entities to find WHICH entity matches a concept, search_lore to find WHERE in the prose it is said or detail too deep for a description.

search_lore

Selects the world used when a tool call omits world_id. Not needed with a single world. Takes effect on the next call. Accepts a worldId returned by list_my_worlds.

set_active_world

Modifies an existing entity. The `updates` object accepts exactly four optional keys: `properties` (object), `tags` (string array), `description` (string), `name` (string). Any other top-level key is rejected — this prevents silent no-ops from invented field shapes. `merge_mode` controls how `properties` is combined with the existing object (the other three keys always replace when present). `merge` (default): provided property keys are layered onto existing properties — unspecified keys are preserved. To delete a property, set its value to `null` (e.g. `properties: { alias: null }`). `replace`: when `properties` is provided, it overwrites the entire properties object wholesale; `null` values are stored as-is. Limits: `properties` may nest objects/arrays but is bounded (≤5 deep, ≤100 values, ≤16KB); `name` ≤255, `description` ≤2000 chars, ≤30 tags. Put long-form prose in lore, not properties/description. Optional `expected_version`: the write applies only if the entity is still at that version, otherwise nothing changes and the call fails with `VERSION_CONFLICT` carrying the current version. Use it when another writer may be editing the same entity: read `version`, then send it back. Omit it for last-write-wins.

update_entity

Modifies an existing lore chunk. Provided fields (`title`, `content`, `display_index`) replace their current values wholesale — `content` is not patched, so to edit prose, first fetch the full text with get_entity_lore, then send the complete revised content. Omitted fields are unchanged. Limits: `title` ≤255, `content` ≤10000 chars.

update_entity_lore

Modifies relationship properties. Can also set started and ended for temporal lifecycle, or clear ended (set to null) to reactivate a historical relationship. `updates` may nest objects/arrays but is bounded (≤5 deep, ≤100 values, ≤16KB); started/ended ≤64 chars. Optional `expected_version`: the write applies only if the relationship is still at that version, otherwise nothing changes and the call fails with `VERSION_CONFLICT` carrying the current version.

update_relationship

Replaces the world's creator-authored instructions (rules, style, constraints, lore) in full. There is no partial merge — call get_world_instructions first and include everything that should remain. An empty string clears the instructions. Only the world owner, or an editor the owner has delegated to, can use this tool.

update_world_instructions