@syndicai/stack-mcp 0.1.1 → 0.2.1

package/README.md

@@ -1,6 +1,8 @@
 # `@syndicai/stack-mcp`
 
-Local stdio MCP server for SyndicAI Stack. Agents (OpenCode, Cursor, etc.) talk to this process; it calls satellite Memory REST with your API key. Prefer `path` for PDF/image ingest so file bytes never enter the model context.
+Local stdio MCP server for SyndicAI Stack. Agents (OpenCode, Cursor, etc.) talk to this process; it calls satellite Memory REST with your API key.
+
+Ingest accepts **text / markdown / code only**. Convert PDFs and images to markdown on the client before calling `memory_ingest`. Prefer a local filesystem `path` so file bytes never enter the model context. Embeddings run on the shared stack-datalayer (CPU Granite), not on the satellite GPU.
 
 ## Configure
 
@@ -37,11 +39,11 @@ Monorepo / unpublished:
 
 ## Tools
 
-| Tool                   | Purpose                                              |
-| ---------------------- | ---------------------------------------------------- |
-| `memory_search`        | Hybrid retrieve                                      |
-| `memory_ingest`        | Create/resume ingest (`path` preferred for binaries) |
-| `memory_ingest_status` | Poll job                                             |
+| Tool                   | Purpose                                                                 |
+| ---------------------- | ----------------------------------------------------------------------- |
+| `memory_search`        | Hybrid retrieve                                                         |
+| `memory_ingest`        | Start ingest async; returns `jobId` (`path` or `text`; PDF/image rejected) |
+| `memory_ingest_status` | Poll job until `completed` / `failed`                                      |
 
 ## Dev
 
@@ -55,10 +57,10 @@ Build output: `dist/apps/stack-mcp/` (workspace root), including copied `package
 
 ## Publish
 
+From the monorepo root (builds into `dist/apps/stack-mcp`, then publishes that folder):
+
 ```bash
-pnpm nx run stack-mcp:build --tui=false
-cd dist/apps/stack-mcp
-npm publish
+pnpm publish:stack-mcp
 ```
 
 Do **not** publish from `apps/stack-mcp` — compiled JS lives under workspace `dist/`.

package/ingest-source.js

@@ -7,6 +7,15 @@ const TEXT_CONTENT_TYPES = new Set([
     'application/json',
     'text/csv',
 ]);
+const REJECTED_CONTENT_TYPES = new Set([
+    'application/pdf',
+    'image/png',
+    'image/jpeg',
+    'image/jpg',
+    'image/webp',
+    'image/gif',
+]);
+export const CONVERSION_REQUIRED_MESSAGE = 'PDF and image ingest is not supported. Convert to markdown or plain text on the client, then ingest text/markdown.';
 /**
  * Build the Memory REST ingest JSON body. When `path` is set, reads the file
  * locally so the LLM never needs to supply bytes.
@@ -24,31 +33,35 @@ export async function buildIngestBody(args) {
     };
     if (args.path?.trim()) {
         const filePath = args.path.trim();
-        const buf = await readFile(filePath);
         const contentType = base.contentType || guessContentType(filePath);
-        if (isTextContentType(contentType)) {
-            return {
-                ...base,
-                contentType,
-                text: buf.toString('utf8'),
-                path: filePath,
-            };
+        assertAllowedContentType(contentType);
+        if (!isTextContentType(contentType)) {
+            throw new Error(`${CONVERSION_REQUIRED_MESSAGE} Unsupported contentType for path ingest: ${contentType}`);
         }
+        const buf = await readFile(filePath);
         return {
             ...base,
             contentType,
-            binaryBase64: buf.toString('base64'),
+            text: buf.toString('utf8'),
             path: filePath,
         };
     }
-    if (args.text !== undefined || args.binaryBase64 !== undefined) {
+    if (args.text !== undefined) {
+        assertAllowedContentType(base.contentType);
         return {
             ...base,
             text: args.text,
-            binaryBase64: args.binaryBase64,
         };
     }
-    throw new Error('Provide path, text, or binaryBase64 for memory_ingest');
+    throw new Error('Provide path or text for memory_ingest');
+}
+function assertAllowedContentType(contentType) {
+    const mime = (contentType.toLowerCase().split(';')[0] ?? contentType)
+        .trim()
+        .toLowerCase();
+    if (REJECTED_CONTENT_TYPES.has(mime)) {
+        throw new Error(CONVERSION_REQUIRED_MESSAGE);
+    }
 }
 function isTextContentType(contentType) {
     const mime = (contentType.toLowerCase().split(';')[0] ?? contentType)
@@ -87,6 +100,6 @@ function guessContentType(filePath) {
         case '.jsx':
             return 'text/javascript';
         default:
-            return 'application/octet-stream';
+            return 'text/plain';
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syndicai/stack-mcp",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "Local stdio MCP server for SyndicAI Stack (Memory and future tools)",
   "type": "module",
   "bin": {

package/tools.js

@@ -67,7 +67,7 @@ export function registerStackMcpTools(server, client) {
     server.registerTool('memory_search', {
         title: 'Search Memory',
         description: 'Hybrid search over the squad Memory corpus (vector + lexical). Returns ranked chunk hits with content and scores. ' +
-            'Query embedding shares the satellite GPU with coding chat: under load embeddings are throttled (lower concurrency) so search may be slower while users are chatting — wait and retry rather than assuming Memory is down.',
+            'Query embeddings run on the stack-datalayer (CPU Granite).',
         inputSchema: {
             query: z.string().describe('Natural-language search query'),
             limit: z
@@ -84,34 +84,35 @@ export function registerStackMcpTools(server, client) {
     }, async (args) => runMemorySearch(client, args));
     server.registerTool('memory_ingest', {
         title: 'Ingest into Memory',
-        description: 'Start (or resume) a Memory ingest job (OCR → chunk → embed → store). Prefer local `path` for PDFs/images so bytes stay out of the model context; ' +
-            'the MCP process reads the file and POSTs JSON (text or binaryBase64) to Memory REST. ' +
-            'Scheduling: coding chat is foreground; OCR stays concurrency 1 and is spaced under load; embeddings use a lower concurrency cap while chat is busy and a higher cap when idle — jobs usually keep progressing rather than pausing. ' +
-            'Poll memory_ingest_status until completed/failed. If status is "paused", keep polling the same jobId — do not open a second ingest for the same sourceKey. Large PDFs can take many minutes when the squad is actively chatting.',
+        description: 'Start a Memory ingest job asynchronously (chunk → embed → store). Returns immediately with jobId and status ' +
+            '(usually "running"; validation failures may be "cancelled"). Accepts text/markdown/code only — convert PDFs/images ' +
+            'to markdown on the client first. Prefer local `path` so file bytes never enter the model context; or pass inline `text`. ' +
+            'Embeddings run on the stack-datalayer (CPU Granite). Poll memory_ingest_status with the jobId until completed/failed. ' +
+            'Do not open a second ingest for the same sourceKey while a non-terminal job exists.',
         inputSchema: {
             sourceKey: z
                 .string()
                 .describe('Stable source identity (e.g. repo path or doc id)'),
             contentType: z
                 .string()
-                .describe('MIME type (e.g. text/plain, application/pdf, image/png). Used with path or inline payload.'),
+                .describe('MIME type (e.g. text/plain, text/markdown). PDF/image types are rejected.'),
             path: z
                 .string()
                 .optional()
-                .describe('Absolute or workspace-relative filesystem path; preferred for PDF/image ingest'),
-            text: z.string().optional().describe('Plain text / source content'),
-            binaryBase64: z
+                .describe('Absolute or workspace-relative filesystem path to a text/markdown/code file'),
+            text: z
                 .string()
                 .optional()
-                .describe('Base64 binary (small fixtures only; prefer path for real PDFs/images)'),
+                .describe('Plain text / markdown / source content'),
             uri: z.string().optional().describe('Optional source URI metadata'),
             collectionId: z.string().optional().describe('Optional collection id'),
         },
     }, async (args) => runMemoryIngest(client, args));
     server.registerTool('memory_ingest_status', {
         title: 'Ingest job status',
-        description: 'Fetch status and checkpoint for a Memory ingest job. Typical statuses: pending/running (in progress, may be slow under chat load), paused (rare — keep polling), completed, failed. ' +
-            'Do not create a new ingest for the same sourceKey while a non-terminal job exists.',
+        description: 'Poll status and checkpoint for a Memory ingest job started via memory_ingest. ' +
+            'Statuses: running (in progress), completed, failed, cancelled. Optional legacy: paused. ' +
+            'Keep polling the same jobId until completed/failed; do not start a second ingest for the same sourceKey while open.',
         inputSchema: {
             jobId: z.string().describe('Ingest job id from memory_ingest'),
         },