@littlebigbrain/mcp 0.6.0 → 0.7.1

package/README.md

@@ -112,7 +112,7 @@ its original identifiers; inspect it with SPARQL when choosing query predicates.
 
 | Tool | Purpose |
 | --- | --- |
-| `lbb_inspect` | Read the schema, graph status, entities, history, and evidence. |
+| `lbb_inspect` | Read the schema, graph status, and entities. |
 | `lbb_query` | Run SPARQL queries, search by meaning, or request summary statistics. |
 | `lbb_rdf` | Import RDF documents or add facts with SPARQL `INSERT DATA`. |
 | `lbb_embeddings` | Inspect search setup and preview the text to embed. |

package/dist/tool-contracts.js

@@ -371,56 +371,7 @@ export const inspectInputSchema = z.discriminatedUnion("action", [
             .int()
             .nonnegative()
             .optional()
-            .describe("Snapshot pin: reproduce the node (state, edges, history) as of this commit_seq."),
-        ...readScope,
-    })
-        .strict(),
-    z
-        .object({
-        action: z.literal("state"),
-        entity_type: z.string(),
-        name: z.string(),
-        relation: z.string().optional(),
-        as_of: z.string().optional(),
-        as_of_commit_seq: z
-            .number()
-            .int()
-            .nonnegative()
-            .optional()
-            .describe("Snapshot pin: reproduce the state as of this commit_seq, hiding later commits. Errors if past head."),
-        ...readScope,
-    })
-        .strict(),
-    z
-        .object({
-        action: z.literal("history"),
-        entity_type: z.string(),
-        name: z.string(),
-        relation: z.string().optional(),
-        ...readScope,
-    })
-        .strict(),
-    z
-        .object({
-        action: z.literal("why"),
-        source_type: z.string(),
-        source_name: z.string(),
-        relation: z.string(),
-        target_type: z.string(),
-        target_name: z.string(),
-        ...readScope,
-    })
-        .strict(),
-    z
-        .object({
-        action: z.literal("transitions"),
-        entity_type: z.string(),
-        name: z.string(),
-        relation: z
-            .string()
-            .describe("State/status relation to trace, e.g. IN_STAGE or HAS_STATUS"),
-        as_of: z.string().optional(),
-        as_of_commit_seq: z.number().int().nonnegative().optional(),
+            .describe("Snapshot pin: reproduce the node's attributes and relationships as of this commit_seq."),
         ...readScope,
     })
         .strict(),

package/dist/tool-runtime.js

@@ -656,7 +656,7 @@ export async function guide(scopedClient) {
         relations,
         capability: {
             search_feedback: "When a result set is useful or clearly wrong, write relevance labels with lbb_commit mode=search_feedback. Use grade 3 for ideal/good results, grade 1 for partially relevant results, and grade 0 for bad results. Include the original query, search_id when present, target identity, rank, score, and an optional split train/eval/unspecified. These labels are stored in __lbb_feedback/main and later exported as qrels-style training/eval data; they are not customer facts.",
-            inspect: "Use lbb_inspect for ontology, schema metadata, the published conformance report, metadata, state/history/why, and this guide. Use lbb_query with SPARQL property paths for exact path queries.",
+            inspect: "Use lbb_inspect for ontology, schema metadata, the published conformance report, metadata, entities, and this guide. Use lbb_query with SPARQL property paths for exact path queries.",
             ontology_decorations: "lbb_inspect action=ontology returns a decoration_status catalog: each ontology decoration is enforced (the engine acts on it — state_reducer, value_type, super_types, properties, supernode_policy; cardinality, which GET /v1/ontology/conformance audits as sh:maxCount; and inverse_name/symmetric, which SPARQL resolves as relation aliases — an inverse name is queryable directly (lowered to ^forward, no stored inverse triple) and a symmetric relation matches both directions), advisory (transitive, temporal_semantics, required), or reserved (stored but unwired — default_weight, resolvable, alias/embedding_fields). You can also always reverse any relation in SPARQL by flipping the triple pattern or using ^forward. Each relation_def also carries edge_count — the number of current edges of that relation in this graph's snapshot — so you can tell at a glance which declared relations are actually populated (edge_count 0 = declared but unused) without a separate summary call.",
             search: "Use lbb_query mode=search to find instances by meaning. It covers every searchable class; filter narrows it by class and by relationship, and the graph checks every hit. To plan a search: (1) lbb_embeddings action=list gives the searchable classes, the facts each text is made from, and the graph's model. (2) lbb_query mode=sparql shows the relationships of a class on a sample: PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> SELECT ?p (COUNT(DISTINCT ?s) AS ?n) (SAMPLE(?l) AS ?example) WHERE { { SELECT ?s WHERE { ?s a <CLASS> } LIMIT 500 } ?s ?p ?o . FILTER(isIRI(?o) && ?p != rdf:type) OPTIONAL { ?o rdfs:label ?l } } GROUP BY ?p ORDER BY DESC(?n); write ?o ?p ?s for the links into the class, and SELECT ?c WHERE { ?c rdfs:subClassOf* <CLASS> } (same prefixes) for its subclasses. (3) lbb_query mode=search with filter [{class}, {via, to}] and explain=true returns the plan: the resolved relationship and entities, the allowed count, and the mode, with no model call. Check it, then run the search without explain. A name in to resolves against labels (a small typo too); an unknown relationship or name answers with the options.",
             query: "Use lbb_query for structured SPARQL-subset bodies, SPARQL text, and canned analysis. SPARQL is the only query surface. A mode=structured body is { patterns: [{ subject, predicate, object }], filters?, group_by?, group_keys?, aggregates?, having? }; a pattern `predicate` is a relation name and is case-insensitive. mode=structured GROUP BY is not limited to entity identity: group_keys can key on a typed scalar property or calendar bucket. In SPARQL text, relations are <https://littlebigbrain.com/r/NAME> and types <https://littlebigbrain.com/class/NAME>. Each query pins one published watermark.",

package/dist/tools.js

@@ -7,7 +7,7 @@ import { analyze, assertCursorScope, contentHashKey, decodeQueryCursor, effectiv
 export function registerLbbTools(server, client, options = {}) {
     registerRdfTool(server, client);
     server.registerTool("lbb_inspect", {
-        description: "Read graph context and exact graph facts. Actions: guide, graphs, publication, ontology, ontology_conformance, schema, ontology_search, metadata, entity, state, history, transitions, why. graphs works before bootstrap; publication reports whether writes are queryable. ontology and schema return complete entries with page_size, section and cursor; follow next until absent. schema reads active native ontology/SHACL metadata without running validation. Query asserted RDF/OWL axioms separately with lbb_query. ontology_conformance serves the durable report referenced by the pinned published root. entity returns one node's metadata, scalar attributes, bounded Base-backed edge neighborhood, history, and observations. Use lbb_query with SPARQL property paths for precise path selection.",
+        description: "Read graph context and exact graph facts. Actions: guide, graphs, publication, ontology, ontology_conformance, schema, ontology_search, metadata, entity. graphs works before bootstrap; publication reports whether writes are queryable. ontology and schema return complete entries with page_size, section and cursor; follow next until absent. schema reads active native ontology/SHACL metadata without running validation. Query asserted RDF/OWL axioms separately with lbb_query. ontology_conformance serves the durable report referenced by the pinned published root. entity returns one node's attributes and current relationships from the RDF read. For a node's past values, run SPARQL with as_of_commit_seq through lbb_query. Use lbb_query with SPARQL property paths for precise path selection.",
         inputSchema: inspectWireSchema,
         annotations: READ_ONLY,
     }, (rawArgs) => {
@@ -51,46 +51,6 @@ export function registerLbbTools(server, client, options = {}) {
                         asOf: args.as_of,
                         asOfCommitSeq: args.as_of_commit_seq,
                     });
-                case "state":
-                    return target.currentState({
-                        entity: {
-                            entity_type: args.entity_type,
-                            name: args.name,
-                        },
-                        relations: args.relation ? [args.relation] : null,
-                        as_of_valid_time: args.as_of ?? null,
-                        as_of_commit_seq: args.as_of_commit_seq ?? null,
-                    });
-                case "history":
-                    return target.history({
-                        source: {
-                            entity_type: args.entity_type,
-                            name: args.name,
-                        },
-                        relation: args.relation ?? null,
-                    });
-                case "why":
-                    return target.why({
-                        source: {
-                            entity_type: args.source_type,
-                            name: args.source_name,
-                        },
-                        relation: args.relation,
-                        target: {
-                            entity_type: args.target_type,
-                            name: args.target_name,
-                        },
-                    });
-                case "transitions":
-                    return target.transitions({
-                        entity: {
-                            entity_type: args.entity_type,
-                            name: args.name,
-                        },
-                        relation: args.relation,
-                        as_of_valid_time: args.as_of ?? null,
-                        as_of_commit_seq: args.as_of_commit_seq ?? null,
-                    });
             }
         });
     });
@@ -301,7 +261,9 @@ export function registerLbbTools(server, client, options = {}) {
         }
         if (args.mode === "search") {
             const searchArgs = args;
-            return run(client, "lbb_query.search", undefined, async () => {
+            // The caller's detail shapes the hits like every other mode: compact
+            // trims to 5 hits of 300 characters, standard and full return more.
+            return run(client, "lbb_query.search", searchArgs.detail, async () => {
                 const target = scoped(client, searchArgs.graph);
                 return target.embeddings.search({
                     embedding: searchArgs.embedding,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@littlebigbrain/mcp",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "MCP server for little big brain: search, graph queries, and data import",
   "license": "Apache-2.0",
   "repository": {
@@ -52,7 +52,7 @@
     "test:coverage": "npm run clean:test && tsc -p tsconfig.test.json && node --test --experimental-test-coverage --test-coverage-include=test-dist/*.js --test-coverage-exclude=test-dist/*.test.js --test-coverage-exclude=test-dist/stdio.js --test-coverage-exclude=test-dist/test-support.js --test-coverage-lines=90 --test-coverage-branches=70 --test-coverage-functions=85 \"test-dist/**/*.test.js\""
   },
   "dependencies": {
-    "@littlebigbrain/client": "^0.14.0",
+    "@littlebigbrain/client": "^0.15.0",
     "@modelcontextprotocol/sdk": "^1",
     "zod": "^3"
   },