@littlebigbrain/mcp 0.2.7 → 0.3.0

package/README.md

@@ -58,10 +58,10 @@ missing.
 
 | Tool | Use it for |
 | --- | --- |
-| `lbb_search` | hybrid retrieval, multi-query fusion, optional path following |
+| `lbb_search` | hybrid retrieval, multi-query fusion, and semantic graph results |
 | `lbb_decode` | constrained relation decoding |
 | `lbb_ground` | vocabulary completion and resolution |
-| `lbb_inspect` | ontology, schema, entity, state, history, provenance, traversal |
+| `lbb_inspect` | ontology, schema, entity, state, history, and provenance |
 | `lbb_query` | SPARQL and structured analytics |
 | `lbb_commit` | facts, properties, and embeddings |
 | `lbb_observe` | conversation episodes plus reviewed extraction |

package/dist/tool-contracts.js

@@ -358,18 +358,6 @@ export const inspectInputSchema = z.discriminatedUnion("action", [
         ...readScope,
     })
         .strict(),
-    z
-        .object({
-        action: z.literal("traverse"),
-        entity_type: z.string(),
-        name: z.string(),
-        relations: z.array(z.string()).optional(),
-        direction: z.enum(["out", "in", "both"]).optional(),
-        max_hops: z.number().int().positive().max(6).optional(),
-        top_k: z.number().int().positive().optional(),
-        ...readScope,
-    })
-        .strict(),
     z
         .object({
         action: z.literal("transitions"),

package/dist/tool-runtime.js

@@ -754,9 +754,9 @@ export async function guide(scopedClient) {
         entity_types: entityTypes,
         relations,
         capability: {
-            search: "Use lbb_search for natural-language retrieval, optional multi-query fusion, and optional path following.",
+            search: "Use lbb_search for natural-language retrieval and optional multi-query fusion. Semantic graph search may include internally scored paths in its result set.",
             search_feedback: "After a lbb_search 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, exact traversals, and this guide.",
+            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.",
             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 branch'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.",
             query: "Use lbb_query for structured SPARQL-subset bodies, SPARQL text, and canned analysis. 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.",
             write: "Use lbb_commit for fact writes and search relevance feedback; omitted idempotency keys are content-derived so retries dedupe. Set typed scalar attributes via entity_properties once the field is registered (add it on a live graph with lbb_configure evolve_ontology add_property). For feedback, use mode=search_feedback rather than fact triplets.",

package/dist/tools.js

@@ -1,9 +1,9 @@
 import { z } from "zod";
 import { IDEMPOTENT_WRITE, MUTATING, READ_ONLY, configureInputSchema, configureWireSchema, detailSchema, graphScope, inspectInputSchema, inspectWireSchema, jsonObjectSchema, queryInputSchema, queryWireSchema, searchFeedbackSchema, } from "./tool-contracts.js";
-import { analyze, assertCursorScope, contentHashKey, decodeQueryCursor, effectiveRowLimit, enrichError, errorResult, guide, normalizeDetail, normalizeLbbIris, ontologyDefineBody, queryCommitPin, queryEnvelope, requireString, resolveProfile, rowPageFrom, rowPageNext, run, scoped, searchBody, searchFeedbackHint, stableJson, toolResult, } from "./tool-runtime.js";
+import { analyze, assertCursorScope, contentHashKey, decodeQueryCursor, effectiveRowLimit, enrichError, errorResult, guide, normalizeDetail, normalizeLbbIris, ontologyDefineBody, queryCommitPin, queryEnvelope, requireString, rowPageFrom, rowPageNext, run, scoped, searchBody, searchFeedbackHint, stableJson, toolResult, } from "./tool-runtime.js";
 export function registerLbbTools(server, client) {
     server.registerTool("lbb_search", {
-        description: "Natural-language retrieval over Little Big Brain. Use `query` for one phrasing, `queries` for reciprocal-rank fusion across phrasings, and `follow_paths: true` when you want bounded graph paths from text-resolved seed entities. When you can judge returned results, call lbb_commit mode=search_feedback with good=3, partial=1, bad=0 so Little Big Brain can build customer-specific qrels for embedding training.",
+        description: "Natural-language retrieval over Little Big Brain. Use `query` for one phrasing or `queries` for reciprocal-rank fusion across phrasings. Semantic graph search can return internally scored paths alongside entity and assertion results. When you can judge returned results, call lbb_commit mode=search_feedback with good=3, partial=1, bad=0 so Little Big Brain can build customer-specific qrels for embedding training.",
         inputSchema: {
             query: z.string().optional().describe("Natural-language query"),
             queries: z
@@ -12,10 +12,7 @@ export function registerLbbTools(server, client) {
                 .optional()
                 .describe("Multiple phrasings to fuse"),
             mode: z.enum(["hybrid", "bm25", "vector", "lexical"]).optional(),
-            follow_paths: z.boolean().optional(),
             top_k: z.number().int().positive().optional(),
-            max_hops: z.number().int().positive().max(6).optional(),
-            direction: z.enum(["out", "in", "both"]).optional(),
             profile: z
                 .enum(["ndcg_v1", "graph_aware_v1", "baseline", "scored_atom_v1"])
                 .optional(),
@@ -33,7 +30,7 @@ export function registerLbbTools(server, client) {
             ...graphScope,
         },
         annotations: READ_ONLY,
-    }, ({ query, queries, mode, follow_paths, top_k, max_hops, direction, profile, as_of, as_of_commit_seq, detail, graph, branch, }) => run(client, "lbb_search", detail, () => {
+    }, ({ query, queries, mode, top_k, profile, as_of, as_of_commit_seq, detail, graph, branch, }) => run(client, "lbb_search", detail, () => {
         const target = scoped(client, graph, branch);
         if (queries?.length) {
             return target.multiSearch({
@@ -54,24 +51,6 @@ export function registerLbbTools(server, client) {
             });
         }
         const q = requireString(query, "query");
-        if (follow_paths) {
-            return target.semanticTraverse({
-                query: q,
-                seed_top_k: Math.min(top_k ?? 3, 10),
-                search: {
-                    lexical: true,
-                    bm25: true,
-                    vector: true,
-                    consistency: "strong",
-                    profile: resolveProfile(profile),
-                },
-                direction: direction ?? "both",
-                max_hops: max_hops ?? 2,
-                max_frontier_entities: 50,
-                max_paths: top_k ?? 25,
-                explain: false,
-            });
-        }
         return target.graphSearch(searchBody({
             query: q,
             mode,
@@ -168,7 +147,7 @@ export function registerLbbTools(server, client) {
         });
     }));
     server.registerTool("lbb_inspect", {
-        description: "Read graph context and exact graph facts. Actions: guide, ontology, ontology_conformance, schema, ontology_search, metadata, entity, state, history, transitions, why, traverse. schema reads active ontology/SHACL bundle metadata without running validation. ontology_conformance serves the durable report referenced by the pinned published root. entity returns one node's metadata, scalar attributes, bounded edge neighborhood, history, and observations. Use traverse for bounded path expansion or lbb_query for precise SPARQL edge selection.",
+        description: "Read graph context and exact graph facts. Actions: guide, ontology, ontology_conformance, schema, ontology_search, metadata, entity, state, history, transitions, why. schema reads active ontology/SHACL bundle metadata without running validation. 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.",
         inputSchema: inspectWireSchema,
         annotations: READ_ONLY,
     }, (rawArgs) => {
@@ -239,18 +218,6 @@ export function registerLbbTools(server, client) {
                             name: args.target_name,
                         },
                     });
-                case "traverse":
-                    return target.traverse({
-                        start: {
-                            entity_type: args.entity_type,
-                            name: args.name,
-                        },
-                        relations: args.relations ?? null,
-                        direction: args.direction ?? "both",
-                        max_hops: args.max_hops ?? 2,
-                        max_frontier_entities: 50,
-                        max_paths: args.top_k ?? 25,
-                    });
                 case "transitions":
                     return target.transitions({
                         entity: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@littlebigbrain/mcp",
-  "version": "0.2.7",
+  "version": "0.3.0",
   "description": "MCP server for little big brain — graph and hybrid search tools for agents",
   "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.9.0",
+    "@littlebigbrain/client": "^0.10.0",
     "@modelcontextprotocol/sdk": "^1",
     "zod": "^3"
   },