Supports running JavaScript code in a sandboxed environment to perform data analysis and script execution.
Provides OS-level sandboxing via bubblewrap for the secure execution of multi-language scripts and system commands.
Leverages sandbox-exec to provide a secure, isolated environment for executing code and shell commands on macOS.
Provides a secure environment to execute Node.js code and scripts for task automation and tool execution.
Enables sandboxed execution of Python scripts for data processing and code verification with high token efficiency.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Token-Efficient MCP ServerFilter sales.csv for rows where price > 500 and show a summary"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Token-Efficient MCP Server
A project-agnostic MCP (Model Context Protocol) server that provides 95%+ token savings through sandboxed data processing, progressive tool loading, and multi-language code execution.
🚀 Key Features
Multi-Language Code Execution
Execute code in sandboxed environment:
Python, Bash, Node.js/JavaScript support
Critical for agent systems (initializer, coding, tester, verifier)
Run commands, tests, and validations with 98% token savings
Progressive Tool Disclosure
Load tools on-demand to reduce context usage:
Level 1: Tool names only (~100 tokens)
Level 2: Names + summaries (~2K tokens)
Level 3: Full definitions (only when needed)
Sandboxed Data Processing
Process data securely before returning to context:
CSV filtering and aggregation (99% savings)
Log file analysis (95% savings)
Code execution with output filtering
Token measurement and optimization
Project Agnostic
Works with any project that needs:
Multi-language code execution
Large dataset processing
Log analysis
Token optimization
📦 Installation
# Clone the repository
git clone https://github.com/your-repo/token-efficient-mcp.git
cd token-efficient-mcp
# Install dependencies
npm install
# Build TypeScript
npm run build⚙️ Configuration
Add to your global ~/.claude.json:
{
"mcpServers": {
"token-efficient": {
"command": "srt",
"args": [
"node",
"/path/to/token-efficient-mcp/dist/index.js"
]
}
}
}Note: The srt command provides OS-level sandboxing via sandbox-exec (macOS) or bubblewrap (Linux).
🛠️ Available Tools
1. execute_code
Execute code in multiple languages with sandboxing.
// Run bash commands
execute_code({
code: "npm test",
language: "bash"
})
// Run Python scripts
execute_code({
code: "import sys; print(sys.version)",
language: "python"
})
// Run Node.js code
execute_code({
code: "console.log('Hello from Node')",
language: "node"
})
// Check health endpoint
execute_code({
code: "curl -m 3 http://localhost:8000/api/health",
language: "bash"
})Supported Languages: python, bash, sh, node, javascript
2. list_token_efficient_tools
Discover available tools with progressive disclosure.
// Level 1: Names only (100 tokens)
list_token_efficient_tools({ level: "names_only" })
// Level 2: Summaries (2K tokens)
list_token_efficient_tools({ level: "summary" })
// Level 3: Full definitions
list_token_efficient_tools({ level: "full" })4. process_csv
Process CSV files with filtering and aggregation.
// Example: Find expensive stocks
process_csv({
file_path: "data/stocks.csv",
filter_expr: "price > 100 and volume > 1000000",
columns: ["symbol", "price", "volume", "change"],
limit: 10,
response_format: "summary"
})5. process_logs
Filter and analyze log files efficiently.
// Example: Find all errors with context
process_logs({
file_path: "logs/application.log",
pattern: "ERROR|CRITICAL",
context_lines: 2,
limit: 50,
response_format: "summary"
})6. get_token_savings_report
Get optimization tips and savings potential.
📊 Token Savings Examples
Code Execution
// Without execute_code: Multi-turn conversation
// Agent: "Should I run npm test?" → User: "Yes" → Run → Parse output
// Estimated: 5,000+ tokens across multiple turns
// With execute_code: Single call
execute_code({ code: "npm test", language: "bash" })
// Returns: { success: true, output: "Tests passed", exit_code: 0 }
// Result: 200 tokens (98% savings)CSV Processing
// Without optimization: 200,000 tokens
// All 10,000 rows returned to context
// With token-efficient MCP: 2,000 tokens (99% savings)
// Only 100 filtered rows returnedLog Analysis
// Without optimization: 500,000 tokens
// All 100,000 log lines returned
// With token-efficient MCP: 5,000 tokens (99% savings)
// Only 500 matching lines with context returnedTool Loading
// Traditional MCP: 150,000 tokens
// All tool definitions loaded at startup
// Token-efficient MCP: 2,000 tokens (98.7% savings)
// Tools loaded on-demand🔒 Security
The server uses OS-level sandboxing via srt wrapper:
Filesystem isolation: Limited to temp directories for code execution
Network restrictions: No outbound connections by default
Process monitoring: Timeouts (1-300s) and resource limits
Multi-language support: Sandboxed Python, Bash, Node.js execution
🧪 Testing
# Build the project
npm run build
# Test execute_code tool
node -e "
const { exec } = require('child_process');
const code = \`echo 'Hello from test'\`;
exec(\`node dist/index.js\`, (err, stdout) => {
console.log(stdout);
});
"
# Or test directly with MCP
# The server will be loaded by Claude Code via ~/.claude.json config📈 Performance Metrics
The server tracks and reports:
Input tokens: Size of request
Output tokens: Size of response
Processing efficiency: Items processed per token
Estimated savings: Percentage of tokens saved
Example response:
{
"token_metrics": {
"input_tokens": 250,
"output_tokens": 1500,
"estimated_savings_percent": 98.5
}
}🤝 Contributing
Fork the repository
Create a feature branch
Add tests for new functionality
Ensure token efficiency principles are followed
Submit a pull request
📝 License
MIT License - see LICENSE file for details.
🔗 Related Resources
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.