Return a COMPACT, curated map of the current SPOKE graph: node labels with counts and a Source->REL->Target edge directory with counts and cost flags.

This is derived live from the database, so it reflects the real, current schema (robust to new/renamed labels or edges). It is small and cached - call it ONCE near the start of a task, then rely on resolve_entity + query_spoke. Use the edge_directory to pick the exact relationship type that connects two entity types before writing Cypher.

Map a free-text name, synonym, or identifier to the canonical SPOKE node(s).

Use this BEFORE query_spoke. It handles the things that make naive queries fail: case-sensitivity (exact {name:...} is case-sensitive), apostrophes, synonyms/brand names, and cross-vocabulary identifiers (DOID, Entrez, Ensembl, DrugBank, UMLS CUI, UBERON, GO). It uses SPOKE's range and full-text indexes, so it is fast and never scans the whole graph.

Returns ranked candidates: {label, name, identifier, matched_on, score}. Then query by the returned exact name or identifier via the parameters argument of query_spoke. If several candidates look plausible, state which one you picked and why.

Show what a node is ACTUALLY connected to: its relationship types, the neighbour label on the other end, the direction, and the count for each.

Use this to (a) decide which relationship to traverse for a question, and (b) avoid thrashing - if a node has no edge of the type you expected (e.g. a disease with no PRESENTS_DpS symptoms, or no LOCALIZES_DlA anatomy), this tells you immediately so you can report the absence instead of guessing more queries. Also ideal for open-ended "how is X connected / what is near X" questions. The node is resolved first (handles case / apostrophes / ids).

Returns {node:{label,name,identifier}, relationships:[{dir, rel, neighbor_label, count}]}.

Find the shortest connecting path(s) between two entities in SPOKE - the right tool for "how are X and Y connected / what links X to Y / shortest path" and subgraph-bridge questions. Both endpoints are resolved first (case / apostrophe / id safe), then a bounded bidirectional allShortestPaths search runs (anchored, so it is fast and cannot scan the graph). Returns each path as an ordered list of nodes and the relationship types between them - so you can read off the intermediate nodes and mechanism in ONE call instead of probing many queries.

If no path is found within max_hops, that is reported (try a larger max_hops, or the entities are only distantly connected). Returns {source, target, max_hops, paths:[{hops, nodes:[...], rels:[...]}]}.

Execute a read-only Cypher query on SPOKE for biomedical knowledge inference.

Behaviour built in for you:

• Only read queries are allowed (writes are rejected).

• An unbounded, non-aggregate query gets a safety LIMIT appended so it cannot accidentally scan the 43M-node graph; aggregations and queries with your own LIMIT are left as-is.

• A transaction timeout aborts pathological queries instead of hanging.

• Output is trimmed (noisy HTML/link fields removed, long strings cut) and capped in size to stay efficient.

Tips: resolve names first with resolve_entity; use the edge_directory from get_spoke_schema to choose relationship types; pass literals via parameters.