Zentrix Agentic Workbench

by deslito

300 downloads

Not rated

GitHub

About

A short summary of what the server does. Example: Modular agentic AI workflows for dataset cleaning and orchestration.

Details

Author: deslito
Downloads: 300
Categories: Other, Automation

- Combines synthetic data with external Hugging Face datasets
- Generates multi-tool invocation and file-access dialogues
- Validates and normalizes dataset schemas automatically
- Outputs a final balanced training set as training_set.jsonl
- Supports evaluation using MCP.so for quality metrics
- Offers quick merge-only mode for iterative development

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name Zentrix Agentic Workbench

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "zentrix agentic workbench": {
            "zentrix": {
                "command": "node",
                "args": [
                    "dist/server.js"
                ],
                "env": {
                    "PORT": "3000",
                    "NODE_ENV": "production",
                    "DATASET_PATH": "/app/datasets/training_set.jsonl",
                    "KIMI_API_KEY": "your-kimi-api-key",
                    "KIMI_MODEL": "kimi-v1",
                    "LOCAL_API_URL": "http://localhost:3000",
                    "PROD_API_URL": "https://your-service-name.mcp.so"
                },
                "mounts": {
                    "../final_datasets": "/app/datasets"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "zentrix agentic workbench": {
            "zentrix": {
                "command": "node",
                "args": [
                    "dist/server.js"
                ],
                "env": {
                    "PORT": "3000",
                    "NODE_ENV": "production",
                    "DATASET_PATH": "/app/datasets/training_set.jsonl",
                    "KIMI_API_KEY": "your-kimi-api-key",
                    "KIMI_MODEL": "kimi-v1",
                    "LOCAL_API_URL": "http://localhost:3000",
                    "PROD_API_URL": "https://your-service-name.mcp.so"
                },
                "mounts": {
                    "../final_datasets": "/app/datasets"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "zentrix agentic workbench": {
            "zentrix": {
                "command": "node",
                "args": [
                    "dist/server.js"
                ],
                "env": {
                    "PORT": "3000",
                    "NODE_ENV": "production",
                    "DATASET_PATH": "/app/datasets/training_set.jsonl",
                    "KIMI_API_KEY": "your-kimi-api-key",
                    "KIMI_MODEL": "kimi-v1",
                    "LOCAL_API_URL": "http://localhost:3000",
                    "PROD_API_URL": "https://your-service-name.mcp.so"
                },
                "mounts": {
                    "../final_datasets": "/app/datasets"
                }
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "zentrix agentic workbench": {
            "zentrix": {
                "command": "node",
                "args": [
                    "dist/server.js"
                ],
                "env": {
                    "PORT": "3000",
                    "NODE_ENV": "production",
                    "DATASET_PATH": "/app/datasets/training_set.jsonl",
                    "KIMI_API_KEY": "your-kimi-api-key",
                    "KIMI_MODEL": "kimi-v1",
                    "LOCAL_API_URL": "http://localhost:3000",
                    "PROD_API_URL": "https://your-service-name.mcp.so"
                },
                "mounts": {
                    "../final_datasets": "/app/datasets"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "zentrix agentic workbench": {
            "zentrix": {
                "command": "node",
                "args": [
                    "dist/server.js"
                ],
                "env": {
                    "PORT": "3000",
                    "NODE_ENV": "production",
                    "DATASET_PATH": "/app/datasets/training_set.jsonl",
                    "KIMI_API_KEY": "your-kimi-api-key",
                    "KIMI_MODEL": "kimi-v1",
                    "LOCAL_API_URL": "http://localhost:3000",
                    "PROD_API_URL": "https://your-service-name.mcp.so"
                },
                "mounts": {
                    "../final_datasets": "/app/datasets"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "zentrix agentic workbench": {
            "zentrix": {
                "command": "node",
                "args": [
                    "dist/server.js"
                ],
                "env": {
                    "PORT": "3000",
                    "NODE_ENV": "production",
                    "DATASET_PATH": "/app/datasets/training_set.jsonl",
                    "KIMI_API_KEY": "your-kimi-api-key",
                    "KIMI_MODEL": "kimi-v1",
                    "LOCAL_API_URL": "http://localhost:3000",
                    "PROD_API_URL": "https://your-service-name.mcp.so"
                },
                "mounts": {
                    "../final_datasets": "/app/datasets"
                }
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "zentrix agentic workbench": {
            "zentrix": {
                "command": "node",
                "args": [
                    "dist/server.js"
                ],
                "env": {
                    "PORT": "3000",
                    "NODE_ENV": "production",
                    "DATASET_PATH": "/app/datasets/training_set.jsonl",
                    "KIMI_API_KEY": "your-kimi-api-key",
                    "KIMI_MODEL": "kimi-v1",
                    "LOCAL_API_URL": "http://localhost:3000",
                    "PROD_API_URL": "https://your-service-name.mcp.so"
                },
                "mounts": {
                    "../final_datasets": "/app/datasets"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "zentrix agentic workbench": {
            "zentrix": {
                "command": "node",
                "args": [
                    "dist/server.js"
                ],
                "env": {
                    "PORT": "3000",
                    "NODE_ENV": "production",
                    "DATASET_PATH": "/app/datasets/training_set.jsonl",
                    "KIMI_API_KEY": "your-kimi-api-key",
                    "KIMI_MODEL": "kimi-v1",
                    "LOCAL_API_URL": "http://localhost:3000",
                    "PROD_API_URL": "https://your-service-name.mcp.so"
                },
                "mounts": {
                    "../final_datasets": "/app/datasets"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "zentrix agentic workbench": {
            "zentrix": {
                "command": "node",
                "args": [
                    "dist/server.js"
                ],
                "env": {
                    "PORT": "3000",
                    "NODE_ENV": "production",
                    "DATASET_PATH": "/app/datasets/training_set.jsonl",
                    "KIMI_API_KEY": "your-kimi-api-key",
                    "KIMI_MODEL": "kimi-v1",
                    "LOCAL_API_URL": "http://localhost:3000",
                    "PROD_API_URL": "https://your-service-name.mcp.so"
                },
                "mounts": {
                    "../final_datasets": "/app/datasets"
                }
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "zentrix agentic workbench": {
            "zentrix": {
                "command": "node",
                "args": [
                    "dist/server.js"
                ],
                "env": {
                    "PORT": "3000",
                    "NODE_ENV": "production",
                    "DATASET_PATH": "/app/datasets/training_set.jsonl",
                    "KIMI_API_KEY": "your-kimi-api-key",
                    "KIMI_MODEL": "kimi-v1",
                    "LOCAL_API_URL": "http://localhost:3000",
                    "PROD_API_URL": "https://your-service-name.mcp.so"
                },
                "mounts": {
                    "../final_datasets": "/app/datasets"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "zentrix agentic workbench": {
            "zentrix": {
                "command": "node",
                "args": [
                    "dist/server.js"
                ],
                "env": {
                    "PORT": "3000",
                    "NODE_ENV": "production",
                    "DATASET_PATH": "/app/datasets/training_set.jsonl",
                    "KIMI_API_KEY": "your-kimi-api-key",
                    "KIMI_MODEL": "kimi-v1",
                    "LOCAL_API_URL": "http://localhost:3000",
                    "PROD_API_URL": "https://your-service-name.mcp.so"
                },
                "mounts": {
                    "../final_datasets": "/app/datasets"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "zentrix agentic workbench": {
            "zentrix": {
                "command": "node",
                "args": [
                    "dist/server.js"
                ],
                "env": {
                    "PORT": "3000",
                    "NODE_ENV": "production",
                    "DATASET_PATH": "/app/datasets/training_set.jsonl",
                    "KIMI_API_KEY": "your-kimi-api-key",
                    "KIMI_MODEL": "kimi-v1",
                    "LOCAL_API_URL": "http://localhost:3000",
                    "PROD_API_URL": "https://your-service-name.mcp.so"
                },
                "mounts": {
                    "../final_datasets": "/app/datasets"
                }
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "zentrix agentic workbench": {
            "zentrix": {
                "command": "node",
                "args": [
                    "dist/server.js"
                ],
                "env": {
                    "PORT": "3000",
                    "NODE_ENV": "production",
                    "DATASET_PATH": "/app/datasets/training_set.jsonl",
                    "KIMI_API_KEY": "your-kimi-api-key",
                    "KIMI_MODEL": "kimi-v1",
                    "LOCAL_API_URL": "http://localhost:3000",
                    "PROD_API_URL": "https://your-service-name.mcp.so"
                },
                "mounts": {
                    "../final_datasets": "/app/datasets"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "zentrix agentic workbench": {
            "zentrix": {
                "command": "node",
                "args": [
                    "dist/server.js"
                ],
                "env": {
                    "PORT": "3000",
                    "NODE_ENV": "production",
                    "DATASET_PATH": "/app/datasets/training_set.jsonl",
                    "KIMI_API_KEY": "your-kimi-api-key",
                    "KIMI_MODEL": "kimi-v1",
                    "LOCAL_API_URL": "http://localhost:3000",
                    "PROD_API_URL": "https://your-service-name.mcp.so"
                },
                "mounts": {
                    "../final_datasets": "/app/datasets"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "zentrix agentic workbench": {
            "zentrix": {
                "command": "node",
                "args": [
                    "dist/server.js"
                ],
                "env": {
                    "PORT": "3000",
                    "NODE_ENV": "production",
                    "DATASET_PATH": "/app/datasets/training_set.jsonl",
                    "KIMI_API_KEY": "your-kimi-api-key",
                    "KIMI_MODEL": "kimi-v1",
                    "LOCAL_API_URL": "http://localhost:3000",
                    "PROD_API_URL": "https://your-service-name.mcp.so"
                },
                "mounts": {
                    "../final_datasets": "/app/datasets"
                }
            }
        }
    }
}

From the repository

Run the full pipeline with python main.py to generate everything from scratch (synthetic data and external downloads) or use python main.py --merge-only to quickly create the training set from existing processed datasets. Additional options include --force, --skip-downloads, and --num-samples. Evaluation is done via evaluate_with_mcp.py with configurable MCP endpoint, API key, and sample limit.

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "zentrix agentic workbench": {
            "zentrix": {
                "command": "node",
                "args": [
                    "dist/server.js"
                ],
                "env": {
                    "PORT": "3000",
                    "NODE_ENV": "production",
                    "DATASET_PATH": "/app/datasets/training_set.jsonl",
                    "KIMI_API_KEY": "your-kimi-api-key",
                    "KIMI_MODEL": "kimi-v1",
                    "LOCAL_API_URL": "http://localhost:3000",
                    "PROD_API_URL": "https://your-service-name.mcp.so"
                },
                "mounts": {
                    "../final_datasets": "/app/datasets"
                }
            }
        }
    }
}

McpServers

{
    "zentrix": {
        "command": "node",
        "args": [
            "dist/server.js"
        ],
        "env": {
            "PORT": "3000",
            "NODE_ENV": "production",
            "DATASET_PATH": "/app/datasets/training_set.jsonl",
            "KIMI_API_KEY": "your-kimi-api-key",
            "KIMI_MODEL": "kimi-v1",
            "LOCAL_API_URL": "http://localhost:3000",
            "PROD_API_URL": "https://your-service-name.mcp.so"
        },
        "mounts": {
            "../final_datasets": "/app/datasets"
        }
    }
}

Kimi Multi-Tool Dataset Generation Pipeline

This project contains a comprehensive pipeline for generating a high-quality, balanced dataset for training and evaluating conversational AI models with multi-tool and file-access capabilities. It combines synthetic data generation with the integration and normalization of external datasets.

The final output is a balanced training set ready for use, located at final_datasets/training_set.jsonl.

Project Structure

- invocation_dataset.py: Generates synthetic dialogues for multi-tool software invocation tasks.
- file_access.py: Generates synthetic dialogues for file-access tasks.
- merge_external_datasets.py: Downloads and normalizes three external tool-use datasets from Hugging Face.
- merge_and_unify.py: Merges the synthetic and external datasets into two main files: multi_tool.jsonl and file_access.jsonl.
- validate_datasets.py: Validates the schema of the merged datasets and performs final normalization.
- create_training_set.py: Combines all records from both datasets into the final training set, preserving 100% of the data.
- main.py: Main script with two modes: full pipeline execution (generates data from scratch) or quick training set creation from existing datasets.

How to Run

Quick Training Set Creation

If you already have the processed datasets in final_datasets/, use:

python main.py --merge-only

This quickly creates the training set using existing data, skipping generation and downloads. Use this for iterating on the final dataset or when you want to ensure 100% data inclusion.

Full Pipeline Execution

To generate everything from scratch, including synthetic data and external downloads:

python main.py

This executes the complete pipeline in order:
1. Generate Synthetic Data: Runs invocation_dataset.py and file_access.py
2. Download External Data: Runs merge_external_datasets.py to download from Hugging Face into downloaded_datasets/
3. Merge & Unify: Runs merge_and_unify.py to combine sources into final_datasets/multi_tool.jsonl and file_access.jsonl
4. Validate: Runs validate_datasets.py to clean and verify the merged files
5. Create Training Set: Runs create_training_set.py to produce final_datasets/training_set.jsonl

Additional Options

- --force: Skip file overwrite prompts - --skip-downloads: Skip external dataset downloads (use only synthetic data) - --merge-only: Quick mode, only create training set from existing data - --num-samples: Control number of synthetic samples to generate

Final Output Files

- final_datasets/training_set.jsonl: The final dataset ready for model training. Contains 100% of records from both multi-tool and file-access tasks, combined and shuffled.
- final_datasets/multi_tool.jsonl: A large, un-sampled collection of all multi-tool invocation dialogues.
- final_datasets/file_access.jsonl: A smaller, un-sampled collection of all file-access dialogues.

Dataset Evaluation

The project includes tooling for evaluating the dataset quality using MCP.so:

Quick Start

python evaluate_with_mcp.py --input final_datasets/training_set.jsonl \
                           --mcp_url https://your-endpoint.mcp.so/serve \
                           --api_key YOUR_API_KEY \
                           --mode messages \
                           --limit 100

Evaluation Process

1. Initial Testing: Start with a small sample (--limit 100) to verify everything works 2. Analysis: Review accuracy metrics and failure patterns 3. Full Evaluation: Run complete dataset evaluation 4. Iteration: Fine-tune dataset based on results

Options

- --mode: Choose between 'messages' (OpenAI-style) or 'prompt' format - --limit: Number of samples to evaluate (omit for full dataset) - --api_key: Your MCP.so API key - --mcp_url: Your MCP endpoint URL

Metrics Tracked

- Exact match accuracy - Response structure consistency - Tool invocation accuracy - Common failure patterns

---

Author: royde
Date: September 2025

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Jump to

Setting up with Highlight

From the repository

Claude Desktop / Cursor

McpServers

Kimi Multi-Tool Dataset Generation Pipeline

Project Structure

How to Run

Quick Training Set Creation

Full Pipeline Execution

Additional Options

Final Output Files

Dataset Evaluation

Quick Start

Evaluation Process

Options

Metrics Tracked

Install

More like this

@mendableai/firecrawl Mcp Server

Umut Naci

Playwright

Sequential Thinking

Filesystem

EverArt