tryll-dataset-builder-mcp 1.0.0

package/README.md

@@ -0,0 +1,121 @@
+# Tryll Dataset Builder — MCP Server
+
+An MCP (Model Context Protocol) server for building structured RAG knowledge base datasets. Use it with Claude Code to create, manage, and export JSON datasets via natural language.
+
+Built by [Tryll Engine](https://tryllengine.com) | [Discord](https://discord.gg/CMnMrmapyB)
+
+## Quick Start
+
+### 1. Install
+
+```bash
+npm install -g tryll-dataset-builder-mcp
+```
+
+### 2. Add to Claude Code
+
+Run in your terminal:
+
+```bash
+claude mcp add dataset-builder -- npx tryll-dataset-builder-mcp
+```
+
+Or manually add to `~/.claude/mcp_settings.json`:
+
+```json
+{
+  "mcpServers": {
+    "dataset-builder": {
+      "command": "npx",
+      "args": ["tryll-dataset-builder-mcp"],
+      "env": {
+        "DATA_DIR": "./datasets"
+      }
+    }
+  }
+}
+```
+
+### 3. Use
+
+Just talk to Claude:
+
+> "Create a knowledge base about Minecraft with categories: Mobs, Blocks, Biomes. Add 10 chunks to each category."
+
+> "Import my existing dataset from ./data/minecraft.json"
+
+> "Search for all chunks mentioning 'diamond' in my project"
+
+## Configuration
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `DATA_DIR` | `./datasets` | Directory where project JSON files are stored |
+
+## Available Tools (18)
+
+### Project Management
+| Tool | Description |
+|------|-------------|
+| `create_project` | Create a new dataset project |
+| `list_projects` | List all projects with stats |
+| `delete_project` | Delete a project |
+| `get_project_stats` | Detailed statistics |
+
+### Category Management
+| Tool | Description |
+|------|-------------|
+| `create_category` | Add a category to a project |
+| `list_categories` | List categories with chunk counts |
+| `rename_category` | Rename a category |
+| `delete_category` | Delete a category and its chunks |
+
+### Chunk Operations
+| Tool | Description |
+|------|-------------|
+| `add_chunk` | Add a single knowledge chunk |
+| `bulk_add_chunks` | Add multiple chunks at once |
+| `get_chunk` | Get chunk content by ID |
+| `update_chunk` | Update chunk fields |
+| `delete_chunk` | Delete a chunk |
+| `duplicate_chunk` | Clone a chunk |
+| `move_chunk` | Move chunk between categories |
+
+### Search & Export
+| Tool | Description |
+|------|-------------|
+| `search_chunks` | Search by ID or text content |
+| `export_project` | Export as flat JSON (RAG-ready) |
+| `import_json` | Import existing JSON dataset |
+
+## Export Format
+
+The exported JSON is a flat array, compatible with the [Dataset Builder web app](https://github.com/Skizziik/json_creator) and ready for RAG pipelines:
+
+```json
+[
+  {
+    "id": "creeper",
+    "text": "A Creeper is a hostile mob that silently approaches players and explodes...",
+    "metadata": {
+      "page_title": "Creeper",
+      "source": "Minecraft Wiki",
+      "license": "CC BY-NC-SA 3.0",
+      "type": "hostile_mob",
+      "health": "20"
+    }
+  }
+]
+```
+
+## Example Prompts
+
+- *"Create a Dark Souls knowledge base with categories for Bosses, Weapons, and Locations"*
+- *"Add 15 chunks about Minecraft mobs with detailed descriptions"*
+- *"Export my project as JSON and save to file"*
+- *"Search for chunks about 'fire' in my dark_souls project"*
+- *"Move chunk 'ancient_dragon' from Bosses to Enemies category"*
+
+## License
+
+MIT

package/index.js

@@ -0,0 +1,406 @@
+#!/usr/bin/env node
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { Store } from "./lib/store.js";
+
+const store = new Store(process.env.DATA_DIR);
+
+const server = new Server(
+  { name: "tryll-dataset-builder", version: "1.0.0" },
+  { capabilities: { tools: {} } }
+);
+
+// ============================================
+// TOOL DEFINITIONS
+// ============================================
+
+const TOOLS = [
+  // ---- Project ----
+  {
+    name: "create_project",
+    description: "Create a new dataset project. Each project stores categories and chunks, exported as a single JSON file.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Project name (used as filename on export)" },
+      },
+      required: ["name"],
+    },
+  },
+  {
+    name: "list_projects",
+    description: "List all existing dataset projects with basic stats (category count, chunk count).",
+    inputSchema: { type: "object", properties: {} },
+  },
+  {
+    name: "delete_project",
+    description: "Permanently delete a project and all its data.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Project name to delete" },
+      },
+      required: ["name"],
+    },
+  },
+  {
+    name: "get_project_stats",
+    description: "Get detailed statistics for a project: category names, total chunks, average text length, longest/shortest chunk.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Project name" },
+      },
+      required: ["name"],
+    },
+  },
+
+  // ---- Category ----
+  {
+    name: "create_category",
+    description: "Add a new category to a project. Categories organize chunks by topic (e.g. 'Mobs', 'Weapons', 'Biomes').",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project: { type: "string", description: "Project name" },
+        name: { type: "string", description: "Category name" },
+      },
+      required: ["project", "name"],
+    },
+  },
+  {
+    name: "list_categories",
+    description: "List all categories in a project with chunk counts.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project: { type: "string", description: "Project name" },
+      },
+      required: ["project"],
+    },
+  },
+  {
+    name: "rename_category",
+    description: "Rename an existing category.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project: { type: "string", description: "Project name" },
+        old_name: { type: "string", description: "Current category name" },
+        new_name: { type: "string", description: "New category name" },
+      },
+      required: ["project", "old_name", "new_name"],
+    },
+  },
+  {
+    name: "delete_category",
+    description: "Delete a category and all its chunks.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project: { type: "string", description: "Project name" },
+        name: { type: "string", description: "Category name to delete" },
+      },
+      required: ["project", "name"],
+    },
+  },
+
+  // ---- Chunk ----
+  {
+    name: "add_chunk",
+    description: "Add a single knowledge chunk to a category. Each chunk has a unique ID, text content, and optional metadata (page_title, source, license, plus any custom fields).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project: { type: "string", description: "Project name" },
+        category: { type: "string", description: "Category name" },
+        id: { type: "string", description: "Unique chunk ID (e.g. 'creeper', 'diamond_sword')" },
+        text: { type: "string", description: "Main text content of the chunk (knowledge entry)" },
+        metadata: {
+          type: "object",
+          description: "Optional metadata. Standard fields: page_title, source, license. Any extra fields become custom metadata.",
+          properties: {
+            page_title: { type: "string" },
+            source: { type: "string" },
+            license: { type: "string" },
+          },
+          additionalProperties: { type: "string" },
+        },
+      },
+      required: ["project", "category", "id", "text"],
+    },
+  },
+  {
+    name: "bulk_add_chunks",
+    description: "Add multiple chunks at once to a category. Much faster than adding one by one. Skips chunks with duplicate IDs and reports errors.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project: { type: "string", description: "Project name" },
+        category: { type: "string", description: "Category name" },
+        chunks: {
+          type: "array",
+          description: "Array of chunk objects, each with id, text, and optional metadata",
+          items: {
+            type: "object",
+            properties: {
+              id: { type: "string", description: "Unique chunk ID" },
+              text: { type: "string", description: "Chunk text content" },
+              metadata: { type: "object", additionalProperties: { type: "string" } },
+            },
+            required: ["id", "text"],
+          },
+        },
+      },
+      required: ["project", "category", "chunks"],
+    },
+  },
+  {
+    name: "get_chunk",
+    description: "Get full content of a specific chunk by its ID.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project: { type: "string", description: "Project name" },
+        id: { type: "string", description: "Chunk ID" },
+      },
+      required: ["project", "id"],
+    },
+  },
+  {
+    name: "update_chunk",
+    description: "Update fields of an existing chunk. Only provided fields will be changed.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project: { type: "string", description: "Project name" },
+        id: { type: "string", description: "Current chunk ID" },
+        new_id: { type: "string", description: "New chunk ID (if renaming)" },
+        text: { type: "string", description: "New text content" },
+        page_title: { type: "string", description: "New page title" },
+        source: { type: "string", description: "New source" },
+        license: { type: "string", description: "New license" },
+        metadata: { type: "object", description: "Custom metadata fields to update", additionalProperties: { type: "string" } },
+      },
+      required: ["project", "id"],
+    },
+  },
+  {
+    name: "delete_chunk",
+    description: "Delete a chunk by its ID.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project: { type: "string", description: "Project name" },
+        id: { type: "string", description: "Chunk ID to delete" },
+      },
+      required: ["project", "id"],
+    },
+  },
+  {
+    name: "duplicate_chunk",
+    description: "Create a copy of an existing chunk with a new ID (original_id + '_copy' suffix).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project: { type: "string", description: "Project name" },
+        id: { type: "string", description: "Chunk ID to duplicate" },
+      },
+      required: ["project", "id"],
+    },
+  },
+  {
+    name: "move_chunk",
+    description: "Move a chunk from its current category to a different one.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project: { type: "string", description: "Project name" },
+        id: { type: "string", description: "Chunk ID to move" },
+        target_category: { type: "string", description: "Target category name" },
+      },
+      required: ["project", "id", "target_category"],
+    },
+  },
+
+  // ---- Search & Export ----
+  {
+    name: "search_chunks",
+    description: "Search for chunks by ID or text content across the entire project. Returns matching chunks with preview.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project: { type: "string", description: "Project name" },
+        query: { type: "string", description: "Search query (searches in chunk ID and text)" },
+      },
+      required: ["project", "query"],
+    },
+  },
+  {
+    name: "export_project",
+    description: "Export the project as a flat JSON array — compatible with Dataset Builder web app and ready for RAG systems. Each entry has id, text, and metadata.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project: { type: "string", description: "Project name" },
+        save_to_file: { type: "boolean", description: "If true, saves to a .export.json file in the data directory. Default: false (returns JSON in response)." },
+      },
+      required: ["project"],
+    },
+  },
+  {
+    name: "import_json",
+    description: "Import a JSON array of chunks into a project. Expected format: [{id, text, metadata}, ...]. Skips entries with duplicate IDs.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project: { type: "string", description: "Project name (will be created if it doesn't exist)" },
+        category: { type: "string", description: "Category to import into (default: 'Imported')" },
+        json_path: { type: "string", description: "Absolute path to the JSON file to import" },
+        data: { type: "array", description: "Or provide the JSON array directly instead of a file path", items: { type: "object" } },
+      },
+      required: ["project"],
+    },
+  },
+];
+
+// ============================================
+// LIST TOOLS
+// ============================================
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+
+// ============================================
+// CALL TOOL
+// ============================================
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    let result;
+
+    switch (name) {
+      // ---- Project ----
+      case "create_project":
+        result = store.createProject(args.name);
+        break;
+      case "list_projects":
+        result = store.listProjects();
+        break;
+      case "delete_project":
+        result = store.deleteProject(args.name);
+        break;
+      case "get_project_stats":
+        result = store.getStats(args.name);
+        break;
+
+      // ---- Category ----
+      case "create_category":
+        result = store.createCategory(args.project, args.name);
+        break;
+      case "list_categories":
+        result = store.listCategories(args.project);
+        break;
+      case "rename_category":
+        result = store.renameCategory(args.project, args.old_name, args.new_name);
+        break;
+      case "delete_category":
+        result = store.deleteCategory(args.project, args.name);
+        break;
+
+      // ---- Chunk ----
+      case "add_chunk":
+        result = store.addChunk(args.project, args.category, {
+          id: args.id,
+          text: args.text,
+          metadata: args.metadata,
+        });
+        break;
+      case "bulk_add_chunks":
+        result = store.bulkAddChunks(args.project, args.category, args.chunks);
+        break;
+      case "get_chunk":
+        result = store.getChunk(args.project, args.id);
+        break;
+      case "update_chunk":
+        result = store.updateChunk(args.project, args.id, {
+          newId: args.new_id,
+          text: args.text,
+          page_title: args.page_title,
+          source: args.source,
+          license: args.license,
+          metadata: args.metadata,
+        });
+        break;
+      case "delete_chunk":
+        result = store.deleteChunk(args.project, args.id);
+        break;
+      case "duplicate_chunk":
+        result = store.duplicateChunk(args.project, args.id);
+        break;
+      case "move_chunk":
+        result = store.moveChunk(args.project, args.id, args.target_category);
+        break;
+
+      // ---- Search & Export ----
+      case "search_chunks":
+        result = store.searchChunks(args.project, args.query);
+        break;
+
+      case "export_project": {
+        const exported = store.exportProject(args.project);
+        if (args.save_to_file) {
+          const outPath = store._filePath(args.project).replace('.json', '.export.json');
+          const { writeFileSync } = await import('fs');
+          writeFileSync(outPath, JSON.stringify(exported, null, 2), 'utf-8');
+          result = { exported: exported.length, savedTo: outPath };
+        } else {
+          result = { exported: exported.length, data: exported };
+        }
+        break;
+      }
+
+      case "import_json": {
+        let jsonData = args.data;
+        if (!jsonData && args.json_path) {
+          const { readFileSync } = await import('fs');
+          jsonData = JSON.parse(readFileSync(args.json_path, 'utf-8'));
+        }
+        if (!jsonData) throw new Error('Provide either "json_path" or "data" parameter');
+        result = store.importJSON(args.project, jsonData, args.category);
+        break;
+      }
+
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+
+    return {
+      content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    };
+
+  } catch (err) {
+    return {
+      content: [{ type: "text", text: `Error: ${err.message}` }],
+      isError: true,
+    };
+  }
+});
+
+// ============================================
+// START
+// ============================================
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("Tryll Dataset Builder MCP server running");
+}
+
+main().catch((err) => {
+  console.error("Fatal:", err);
+  process.exit(1);
+});

package/lib/store.js

@@ -0,0 +1,389 @@
+import { readFileSync, writeFileSync, readdirSync, mkdirSync, unlinkSync, existsSync } from 'fs';
+import { join } from 'path';
+import { randomUUID } from 'crypto';
+
+const DEFAULT_LICENSE = 'CC BY-NC-SA 3.0';
+const STANDARD_META = ['page_title', 'source', 'license'];
+
+export class Store {
+  constructor(dataDir) {
+    this.dataDir = dataDir || process.env.DATA_DIR || './datasets';
+    this._ensureDir();
+  }
+
+  _ensureDir() {
+    if (!existsSync(this.dataDir)) {
+      mkdirSync(this.dataDir, { recursive: true });
+    }
+  }
+
+  _filePath(name) {
+    return join(this.dataDir, `${name}.json`);
+  }
+
+  // ---- PROJECT ----
+
+  listProjects() {
+    this._ensureDir();
+    const files = readdirSync(this.dataDir).filter(f => f.endsWith('.json'));
+    return files.map(f => {
+      const name = f.replace(/\.json$/, '');
+      try {
+        const data = this._load(name);
+        const totalChunks = data.categories.reduce((sum, c) => sum + c.chunks.length, 0);
+        return { name, categories: data.categories.length, chunks: totalChunks, createdAt: data.createdAt };
+      } catch {
+        return { name, categories: 0, chunks: 0, createdAt: null };
+      }
+    });
+  }
+
+  createProject(name) {
+    const safeName = name.replace(/[^a-zA-Z0-9_\-. ]/g, '').trim();
+    if (!safeName) throw new Error('Invalid project name');
+    if (existsSync(this._filePath(safeName))) throw new Error(`Project "${safeName}" already exists`);
+    const project = { name: safeName, createdAt: new Date().toISOString(), categories: [] };
+    this._save(safeName, project);
+    return project;
+  }
+
+  deleteProject(name) {
+    const fp = this._filePath(name);
+    if (!existsSync(fp)) throw new Error(`Project "${name}" not found`);
+    unlinkSync(fp);
+    return { deleted: name };
+  }
+
+  getStats(name) {
+    const data = this._load(name);
+    let totalChunks = 0, totalLength = 0, longest = 0, shortest = Infinity;
+    for (const cat of data.categories) {
+      for (const ch of cat.chunks) {
+        totalChunks++;
+        const len = (ch.text || '').length;
+        totalLength += len;
+        if (len > longest) longest = len;
+        if (len < shortest) shortest = len;
+      }
+    }
+    return {
+      project: name,
+      categories: data.categories.length,
+      categoryNames: data.categories.map(c => `${c.name} (${c.chunks.length} chunks)`),
+      totalChunks,
+      avgTextLength: totalChunks ? Math.round(totalLength / totalChunks) : 0,
+      longestChunk: totalChunks ? longest : 0,
+      shortestChunk: totalChunks ? shortest : 0,
+      createdAt: data.createdAt,
+    };
+  }
+
+  // ---- CATEGORY ----
+
+  listCategories(projectName) {
+    const data = this._load(projectName);
+    return data.categories.map(c => ({
+      name: c.name,
+      chunks: c.chunks.length,
+    }));
+  }
+
+  createCategory(projectName, categoryName) {
+    const data = this._load(projectName);
+    const trimmed = categoryName.trim();
+    if (!trimmed) throw new Error('Category name cannot be empty');
+    if (data.categories.some(c => c.name.toLowerCase() === trimmed.toLowerCase())) {
+      throw new Error(`Category "${trimmed}" already exists in project "${projectName}"`);
+    }
+    const cat = { id: randomUUID(), name: trimmed, chunks: [] };
+    data.categories.push(cat);
+    this._save(projectName, data);
+    return cat;
+  }
+
+  renameCategory(projectName, oldName, newName) {
+    const data = this._load(projectName);
+    const cat = this._findCategory(data, oldName);
+    const trimmed = newName.trim();
+    if (!trimmed) throw new Error('New name cannot be empty');
+    if (data.categories.some(c => c.name.toLowerCase() === trimmed.toLowerCase() && c.id !== cat.id)) {
+      throw new Error(`Category "${trimmed}" already exists`);
+    }
+    cat.name = trimmed;
+    this._save(projectName, data);
+    return { old: oldName, new: trimmed };
+  }
+
+  deleteCategory(projectName, categoryName) {
+    const data = this._load(projectName);
+    const idx = data.categories.findIndex(c => c.name.toLowerCase() === categoryName.toLowerCase());
+    if (idx === -1) throw new Error(`Category "${categoryName}" not found`);
+    const removed = data.categories.splice(idx, 1)[0];
+    this._save(projectName, data);
+    return { deleted: removed.name, chunksRemoved: removed.chunks.length };
+  }
+
+  // ---- CHUNK ----
+
+  addChunk(projectName, categoryName, chunk) {
+    const data = this._load(projectName);
+    const cat = this._findCategory(data, categoryName);
+    const id = (chunk.id || '').trim();
+    if (!id) throw new Error('Chunk ID is required');
+    if (this._isIdTaken(data, id)) throw new Error(`Chunk ID "${id}" already exists in this project. Try adding _1, _2 suffix.`);
+
+    const newChunk = {
+      _uid: randomUUID(),
+      id,
+      text: chunk.text || '',
+      metadata: {
+        page_title: chunk.page_title || chunk.metadata?.page_title || '',
+        source: chunk.source || chunk.metadata?.source || '',
+        license: chunk.license || chunk.metadata?.license || DEFAULT_LICENSE,
+      },
+      customFields: this._parseCustomFields(chunk.metadata),
+    };
+    cat.chunks.push(newChunk);
+    this._save(projectName, data);
+    return { id: newChunk.id, category: cat.name };
+  }
+
+  bulkAddChunks(projectName, categoryName, chunks) {
+    const data = this._load(projectName);
+    const cat = this._findCategory(data, categoryName);
+    const added = [];
+    const errors = [];
+
+    for (const chunk of chunks) {
+      const id = (chunk.id || '').trim();
+      if (!id) { errors.push({ id: '(empty)', reason: 'ID is required' }); continue; }
+      if (this._isIdTaken(data, id)) { errors.push({ id, reason: 'Duplicate ID' }); continue; }
+
+      cat.chunks.push({
+        _uid: randomUUID(),
+        id,
+        text: chunk.text || '',
+        metadata: {
+          page_title: chunk.page_title || chunk.metadata?.page_title || '',
+          source: chunk.source || chunk.metadata?.source || '',
+          license: chunk.license || chunk.metadata?.license || DEFAULT_LICENSE,
+        },
+        customFields: this._parseCustomFields(chunk.metadata),
+      });
+      added.push(id);
+    }
+
+    this._save(projectName, data);
+    return { added: added.length, errors: errors.length, details: errors.length ? errors : undefined, ids: added };
+  }
+
+  getChunk(projectName, chunkId) {
+    const data = this._load(projectName);
+    for (const cat of data.categories) {
+      const ch = cat.chunks.find(c => c.id === chunkId);
+      if (ch) return { ...this._formatChunk(ch), category: cat.name };
+    }
+    throw new Error(`Chunk "${chunkId}" not found in project "${projectName}"`);
+  }
+
+  updateChunk(projectName, chunkId, updates) {
+    const data = this._load(projectName);
+    for (const cat of data.categories) {
+      const ch = cat.chunks.find(c => c.id === chunkId);
+      if (!ch) continue;
+
+      if (updates.newId && updates.newId !== chunkId) {
+        if (this._isIdTaken(data, updates.newId, ch._uid)) {
+          throw new Error(`Chunk ID "${updates.newId}" already exists`);
+        }
+        ch.id = updates.newId.trim();
+      }
+      if (updates.text !== undefined) ch.text = updates.text;
+      if (updates.page_title !== undefined) ch.metadata.page_title = updates.page_title;
+      if (updates.source !== undefined) ch.metadata.source = updates.source;
+      if (updates.license !== undefined) ch.metadata.license = updates.license;
+      if (updates.metadata) {
+        const custom = this._parseCustomFields(updates.metadata);
+        if (custom.length) ch.customFields = custom;
+      }
+
+      this._save(projectName, data);
+      return { updated: ch.id, category: cat.name };
+    }
+    throw new Error(`Chunk "${chunkId}" not found`);
+  }
+
+  deleteChunk(projectName, chunkId) {
+    const data = this._load(projectName);
+    for (const cat of data.categories) {
+      const idx = cat.chunks.findIndex(c => c.id === chunkId);
+      if (idx === -1) continue;
+      cat.chunks.splice(idx, 1);
+      this._save(projectName, data);
+      return { deleted: chunkId, category: cat.name };
+    }
+    throw new Error(`Chunk "${chunkId}" not found`);
+  }
+
+  duplicateChunk(projectName, chunkId) {
+    const data = this._load(projectName);
+    for (const cat of data.categories) {
+      const ch = cat.chunks.find(c => c.id === chunkId);
+      if (!ch) continue;
+
+      let newId = chunkId + '_copy';
+      let n = 1;
+      while (this._isIdTaken(data, newId)) { newId = `${chunkId}_copy_${n++}`; }
+
+      const clone = { ...JSON.parse(JSON.stringify(ch)), _uid: randomUUID(), id: newId };
+      cat.chunks.push(clone);
+      this._save(projectName, data);
+      return { original: chunkId, duplicate: newId, category: cat.name };
+    }
+    throw new Error(`Chunk "${chunkId}" not found`);
+  }
+
+  moveChunk(projectName, chunkId, targetCategory) {
+    const data = this._load(projectName);
+    const targetCat = this._findCategory(data, targetCategory);
+    for (const cat of data.categories) {
+      const idx = cat.chunks.findIndex(c => c.id === chunkId);
+      if (idx === -1) continue;
+      if (cat.id === targetCat.id) throw new Error('Chunk is already in that category');
+      const [chunk] = cat.chunks.splice(idx, 1);
+      targetCat.chunks.push(chunk);
+      this._save(projectName, data);
+      return { moved: chunkId, from: cat.name, to: targetCat.name };
+    }
+    throw new Error(`Chunk "${chunkId}" not found`);
+  }
+
+  // ---- SEARCH ----
+
+  searchChunks(projectName, query) {
+    const data = this._load(projectName);
+    const q = query.toLowerCase();
+    const results = [];
+    for (const cat of data.categories) {
+      for (const ch of cat.chunks) {
+        if (ch.id.toLowerCase().includes(q) || (ch.text || '').toLowerCase().includes(q)) {
+          results.push({ id: ch.id, category: cat.name, preview: ch.text.substring(0, 120) + (ch.text.length > 120 ? '...' : '') });
+        }
+      }
+    }
+    return { query, found: results.length, results };
+  }
+
+  // ---- EXPORT / IMPORT ----
+
+  exportProject(projectName) {
+    const data = this._load(projectName);
+    const flat = [];
+    for (const cat of data.categories) {
+      for (const ch of cat.chunks) {
+        const entry = {
+          id: ch.id,
+          text: ch.text,
+          metadata: { ...ch.metadata },
+        };
+        if (ch.customFields) {
+          for (const cf of ch.customFields) {
+            if (cf.key && cf.key.trim()) {
+              entry.metadata[cf.key.trim()] = String(cf.value ?? '');
+            }
+          }
+        }
+        flat.push(entry);
+      }
+    }
+    return flat;
+  }
+
+  importJSON(projectName, jsonArray, categoryName) {
+    if (!Array.isArray(jsonArray)) throw new Error('Import data must be a JSON array');
+
+    let data;
+    try {
+      data = this._load(projectName);
+    } catch {
+      data = this.createProject(projectName);
+    }
+
+    const catName = categoryName || 'Imported';
+    let cat = data.categories.find(c => c.name.toLowerCase() === catName.toLowerCase());
+    if (!cat) {
+      cat = { id: randomUUID(), name: catName, chunks: [] };
+      data.categories.push(cat);
+    }
+
+    let imported = 0, skipped = 0;
+    for (const entry of jsonArray) {
+      const id = (entry.id || '').trim();
+      if (!id) { skipped++; continue; }
+      if (this._isIdTaken(data, id)) { skipped++; continue; }
+
+      const meta = entry.metadata || {};
+      cat.chunks.push({
+        _uid: randomUUID(),
+        id,
+        text: entry.text || '',
+        metadata: {
+          page_title: meta.page_title || '',
+          source: meta.source || '',
+          license: meta.license || DEFAULT_LICENSE,
+        },
+        customFields: Object.entries(meta)
+          .filter(([k]) => !STANDARD_META.includes(k))
+          .map(([key, value]) => ({ key, value: String(value ?? '') })),
+      });
+      imported++;
+    }
+
+    this._save(projectName, data);
+    return { project: projectName, category: catName, imported, skipped };
+  }
+
+  // ---- INTERNAL ----
+
+  _load(name) {
+    const fp = this._filePath(name);
+    if (!existsSync(fp)) throw new Error(`Project "${name}" not found`);
+    return JSON.parse(readFileSync(fp, 'utf-8'));
+  }
+
+  _save(name, data) {
+    this._ensureDir();
+    writeFileSync(this._filePath(name), JSON.stringify(data, null, 2), 'utf-8');
+  }
+
+  _findCategory(data, name) {
+    const cat = data.categories.find(c => c.name.toLowerCase() === name.toLowerCase());
+    if (!cat) throw new Error(`Category "${name}" not found`);
+    return cat;
+  }
+
+  _isIdTaken(data, id, excludeUid) {
+    for (const cat of data.categories) {
+      for (const ch of cat.chunks) {
+        if (ch.id === id && ch._uid !== excludeUid) return true;
+      }
+    }
+    return false;
+  }
+
+  _parseCustomFields(metadata) {
+    if (!metadata || typeof metadata !== 'object') return [];
+    return Object.entries(metadata)
+      .filter(([k]) => !STANDARD_META.includes(k))
+      .map(([key, value]) => ({ key, value: String(value ?? '') }));
+  }
+
+  _formatChunk(ch) {
+    return {
+      id: ch.id,
+      text: ch.text,
+      metadata: ch.metadata,
+      customFields: ch.customFields || [],
+    };
+  }
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "tryll-dataset-builder-mcp",
+  "version": "1.0.0",
+  "description": "MCP server for building RAG knowledge base datasets. Create, manage and export structured JSON datasets via Claude Code.",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "tryll-dataset-builder-mcp": "index.js"
+  },
+  "files": [
+    "index.js",
+    "lib/",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "rag",
+    "dataset",
+    "knowledge-base",
+    "claude",
+    "ai",
+    "tryll-engine"
+  ],
+  "author": "Tryll Engine",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Skizziik/tryll_dataset_builder"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "zod": "^3.24.0"
+  }
+}