audit_world
ChatGPTWorld-scope or entity-scope validation. Set entity_id for entity-scope (default check_types: ["property_gaps"]); omit for world-scope (default check_types: ["property_gaps", "orphaned_entities"]). Returns { check_timestamp, total_issues, next_cursor, issues: [{severity, type, description, entity_id?}] }. There is no `valid` boolean — inspect issues[].severity === "error" to determine validity for entity-scope calls. strict_mode (entity-scope only) emits additional error-severity issues for missing required fields.
create_entities
ChatGPTCreates 1-100 entities in a single call. Pass skip_existing: true to skip entities whose slug already exists (in the DB or earlier in the same batch) instead of failing the whole call; defaults to false (strict — any duplicate fails the entire call). Returns { created, skipped, counts } with skipped items carrying the input fields plus a reason. Validation and duplicate failures are all-or-nothing and list every offending row with its array index in error.details (invalid_rows / duplicate_rows). Limits per entity: name ≤255, description ≤2000 chars, ≤30 tags; properties may nest objects/arrays but is bounded (≤5 deep, ≤100 values, ≤16KB) — put long-form prose in lore, not properties/description. Call get_world_context for the valid entity types.
create_entity_lore
ChatGPTAdds a lore chunk (long-form prose) to an entity. Keep each chunk to one subject or perspective (~50–150 words is ideal); title ≤255, content ≤10000 chars — split larger prose into multiple focused chunks. display_index controls list order; omit it to append at the end. Put structured facts in entity properties and long-form prose in lore. Returns { lore_id, title, word_count, created_at }.
create_relationships
ChatGPTCreates 1-100 relationships in a single call. Stored as directed edges; bidirectional querying is handled at query time. Pass skip_duplicates: true to skip duplicate active edges (existing or in-batch) instead of failing the whole call; defaults to false (strict). Source and target entity types are validated against each relationship type's allowed source/target lists. Call get_world_context (relationship_types) for the valid relationship types AND each type's allowed source/target entity types before composing edges — the type name alone is not enough, since an edge is rejected when the source/target entity types are not in that type's allowed lists. Returns { created, skipped, counts }. Validation and duplicate failures are all-or-nothing and list every offending row with its array index in error.details (invalid_rows / duplicate_rows). Per relationship: properties may nest objects/arrays but is bounded (≤5 deep, ≤100 values, ≤16KB); started/ended ≤64 chars.
delete_entity
ChatGPTPermanently deletes an entity (by slug or UUID). By default (cascade: false) the call is REFUSED if the entity still has any relationships — it returns an ENTITY_HAS_RELATIONSHIPS error naming the count, so you never silently detach its neighbours. Pass cascade: true to delete the entity together with all of its relationships (every edge where it is the source or target). The entity's lore and tags are always removed with it. Optional reason is recorded in the audit trail. Returns { deleted_entity_id, deleted_at, relationships_removed }. There is no undo — to retire a single relationship without losing data, prefer update_relationship with ended instead.
delete_entity_lore
ChatGPTPermanently deletes a lore chunk from an entity. There is no undo. To revise or restructure prose, prefer update_entity_lore over delete-and-recreate — it preserves the chunk's identity and history. Returns { deleted_lore_id, deleted_at }.
delete_relationship
ChatGPTPermanently removes a connection between entities. Reserve for data entry errors — prefer update_relationship with ended to mark a relationship as historical instead.
get_entities
ChatGPTRetrieve 1-20 entities with paginated relationships and lore blocks. Always returns { success, retrieved_count, entities: [...] }, even for one id. Each block is { total, returned, items, next_cursor } and paginates independently via its own limit/cursor/filter; total is advisory (recomputed per request) — page until next_cursor is null. view: "full" (default) returns block items; view: "record" collapses blocks to counts only (items: [], next_cursor: null); the record itself is unchanged. lore.include_content: true adds full lore prose and is safe to change mid-scroll. Cursors are signed, per-entity (pass exactly one entity_id with a cursor) and filter-bound: a mid-scroll filter change returns STALE_CURSOR. Inserts and deletes mid-scroll are safe; reordering lore display_index can repeat or skip a chunk. A self-relationship appears once per direction under direction: "both" — do not de-duplicate on relationship_id.
get_entity_lore
ChatGPTReads lore chunks (long-form prose) on an entity. Omit lore_id to list all chunks as summaries ordered by display_index (returns total_chunks + lore_chunks with lore_id, title, word_count, display_index, timestamps — no content); provide lore_id to fetch one chunk's full content. For incremental reads, pass after (an ISO 8601 timestamp with timezone) to get only chunks created after that instant, in creation order; the response then carries next_after when more remain — pass it back to continue, or mint one from a listed chunk's created_at. limit caps the page and truncates silently: without after no cursor is issued, and total_chunks counts only what was returned. after and limit are ignored when lore_id is given. To find lore by meaning across entities, use search_lore (semantic); to read lore inline with an entity's record and relationships, use get_entities with lore.include_content: true.
get_timeline
ChatGPTReturns a world's events in chronological order. Filters: date range (start_year/end_year/start_month/end_month/start_day/end_day — month refines the boundary year, day refines the boundary month; a day bound needs its year+month bounds, and windows compose across months: Jun 28 – Jul 4 is start_month=6, start_day=28, end_month=7, end_day=4), location_id (events linked to a place), entity_ids (events involving ANY of the listed entities), event_types. All filters combine as AND; entity_ids is OR within itself. view: 'compact' returns {entity_id, name, entity_type} plus the date_ parts; 'summary' (default) adds a `preview` field (the entity's short_description). Cursor-paginated (limit max 100, default 50). Note: currently limited to entity_type 'event' carrying date_ properties; generalizing to other types or custom date schemas is tracked in the temporal-model spike.
get_world_context
ChatGPTCall 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_instructions
ChatGPTReturns 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.
list_my_worlds
ChatGPTStart 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 }.
query_relationships
ChatGPTQuery 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.
search_entities
ChatGPTSearch/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_lore
ChatGPTSemantic 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.
set_active_world
ChatGPTSelects 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.
update_entity
ChatGPTModifies 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_lore
ChatGPTModifies 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_relationship
ChatGPTModifies 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_world_instructions
ChatGPTReplaces 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.
audit_world
Claudecreate_entities
Claudecreate_entity_lore
Claudecreate_relationships
Claudedelete_entity
Claudedelete_entity_lore
Claudedelete_relationship
Claudeget_entities
Claudeget_entity_lore
Claudeget_timeline
Claudeget_world_context
Claudeget_world_instructions
Claudelist_my_worlds
Claudequery_relationships
Claudesearch_entities
Claudesearch_lore
Claudeset_active_world
Claudeupdate_entity
Claudeupdate_entity_lore
Claudeupdate_relationship
Claudeupdate_world_instructions
Claude
