tachibot-mcp 2.0.2

package/smithery.yaml

@@ -0,0 +1,66 @@
+# Smithery configuration file: https://smithery.ai/docs/config#smitheryyaml
+name: "tachibot-mcp"
+description: "Multi-model AI orchestration platform with 26 tools across Perplexity, Grok, OpenAI GPT-5, Gemini, and Qwen. Features YAML workflows, 5 token-optimized profiles (4k-19k), smart routing, and cost controls. Build complex AI pipelines with variable passing and parallel execution."
+version: "2.0.0"
+
+startCommand:
+  type: stdio
+  configSchema:
+    type: "object"
+    title: "TachiBot MCP Configuration"
+    description: "Configuration options for TachiBot MCP - Universal AI Orchestrator"
+    properties:
+      TACHIBOT_PROFILE:
+        type: "string"
+        title: "Tool Profile"
+        description: "Select tool profile: minimal (8 tools, ~4k tokens), research_power (15 tools), code_focus (13 tools), balanced (17 tools, default), full (26 tools, ~19k tokens)"
+        enum: ["minimal", "research_power", "code_focus", "balanced", "full"]
+        default: "balanced"
+      PERPLEXITY_API_KEY:
+        type: "string"
+        title: "Perplexity API Key"
+        description: "API key for Perplexity (web search, research, reasoning)"
+        format: "password"
+      GROK_API_KEY:
+        type: "string"
+        title: "Grok API Key"
+        description: "API key for xAI Grok (code analysis, debugging, architecture)"
+        format: "password"
+      OPENAI_API_KEY:
+        type: "string"
+        title: "OpenAI API Key"
+        description: "API key for OpenAI GPT-5, Qwen, QwQ models"
+        format: "password"
+      GOOGLE_API_KEY:
+        type: "string"
+        title: "Google Gemini API Key"
+        description: "API key for Google Gemini (brainstorming, analysis)"
+        format: "password"
+      OPENROUTER_API_KEY:
+        type: "string"
+        title: "OpenRouter API Key"
+        description: "Optional: OpenRouter API key for additional model access"
+        format: "password"
+    required: []
+  commandFunction: |-
+    (config) => ({
+      command: 'node',
+      args: ['dist/src/server.js'],
+      env: {
+        NODE_ENV: 'production',
+        TACHIBOT_PROFILE: config.TACHIBOT_PROFILE || 'balanced',
+        PERPLEXITY_API_KEY: config.PERPLEXITY_API_KEY || '',
+        GROK_API_KEY: config.GROK_API_KEY || '',
+        OPENAI_API_KEY: config.OPENAI_API_KEY || '',
+        GOOGLE_API_KEY: config.GOOGLE_API_KEY || '',
+        OPENROUTER_API_KEY: config.OPENROUTER_API_KEY || '',
+        TACHI_ENABLE_CACHE: 'true',
+        TACHI_ENABLE_BATCHING: 'true'
+      }
+    })
+
+clients:
+  - claude
+  - cursor
+  - windsurf
+  - cline

package/start.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+# Wrapper script for tachibot-mcp that ensures proper Node.js environment
+
+# Get the directory of this script
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+# Run the server (uses system node or nvm/volta if configured)
+exec node "$DIR/dist/src/server.js"

package/tools.config.json

@@ -0,0 +1,81 @@
+{
+  "description": "TachiBot MCP Tool Configuration - Profile system for managing tool availability",
+  "lastModified": "2025-10-23",
+
+  "activeProfile": "research_power",
+
+  "skills": {
+    "bundled": true,
+    "path": "skills"
+  },
+
+  "availableTools": {
+    "description": "Reference: All available tools - Copy any of these to customProfile.tools to create your own selection",
+    "core": ["think", "focus", "nextThought"],
+    "perplexity": [
+      "perplexity_ask",
+      "perplexity_reason",
+      "perplexity_research"
+    ],
+    "grok": [
+      "grok_reason",
+      "grok_code",
+      "grok_debug",
+      "grok_architect",
+      "grok_brainstorm",
+      "grok_search"
+    ],
+    "openai": ["openai_compare", "openai_brainstorm"],
+    "gemini": [
+      "gemini_brainstorm",
+      "gemini_analyze_code",
+      "gemini_analyze_text"
+    ],
+    "qwen": ["qwen_coder"],
+    "kimi": ["kimi_thinking"],
+    "advanced": ["verifier", "scout", "challenger", "hunter"],
+    "workflow": [
+      "workflow",
+      "list_workflows",
+      "create_workflow",
+      "visualize_workflow"
+    ],
+    "collaborative": ["pingpong", "qwen_competitive"]
+  },
+
+  "customProfile": {
+    "description": "Your custom profile - Toggle tools on/off below. Set enabled: true to activate.",
+    "enabled": false,
+    "tools": {
+      "think": true,
+      "focus": true,
+      "nextThought": true,
+      "perplexity_ask": true,
+      "perplexity_reason": true,
+      "perplexity_research": true,
+      "grok_reason": true,
+      "grok_code": true,
+      "grok_debug": true,
+      "grok_architect": true,
+      "grok_brainstorm": true,
+      "grok_search": true,
+      "openai_compare": true,
+      "openai_brainstorm": true,
+      "gemini_brainstorm": true,
+      "gemini_analyze_code": true,
+      "gemini_analyze_text": true,
+      "qwen_coder": true,
+      "kimi_thinking": true,
+      "verifier": true,
+      "scout": true,
+      "challenger": true,
+      "hunter": false,
+      "workflow": true,
+      "list_workflows": true,
+      "create_workflow": true,
+      "visualize_workflow": true,
+      "pingpong": true,
+      "qwen_competitive": false
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "isolatedModules": true,
+    "outDir": "dist",
+    "strict": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "downlevelIteration": true,
+    "allowSyntheticDefaultImports": true,
+    "lib": ["ES2020"]
+  },
+  "include": ["src/**/*", "scripts/**/*"],
+  "exclude": ["node_modules", "**/__tests__/**", "**/*.test.ts"]
+}

package/workflows/accessibility-code-audit.yaml

@@ -0,0 +1,92 @@
+name: accessibility-code-audit
+description: WCAG 2.2 analysis with AI-powered collaborative fixes
+version: "1.0"
+
+settings:
+  optimization:
+    enabled: true
+    smartRouting: true
+
+steps:
+  # Step 1: Scan for accessibility issues
+  - name: accessibility-scan
+    tool: gemini_analyze_code
+    input:
+      code: "${input}"
+      focus: "general"
+    saveToFile: true
+    output:
+      variable: a11y_scan
+
+  # Step 2: Research WCAG standards
+  - name: wcag-standards
+    tool: perplexity_ask
+    input:
+      query: "WCAG 2.2 accessibility standards and compliance requirements 2025"
+      searchRecency: "month"
+      searchDomain: "general"
+    saveToFile: true
+    output:
+      variable: wcag_standards
+
+  # Step 3: Collaborative fix debate (Gemini + Qwen)
+  - name: fix-generation-debate
+    tool: pingpong
+    input:
+      problem: "Given accessibility issues: ${a11y_scan} and standards: ${wcag_standards}, debate the best fixes"
+      models: ["gemini", "qwen"]
+      rounds: 3
+      style: "collaborative"
+    saveToFile: true
+    output:
+      variable: proposed_fixes
+
+  # Step 4: Verify fixes are correct
+  - name: verify-fixes
+    tool: verifier
+    input:
+      query: "Verify these accessibility fixes are WCAG 2.2 compliant: ${proposed_fixes}"
+      variant: "fact_check"
+      includeSources: true
+    saveToFile: true
+    output:
+      variable: verified_fixes
+
+  # Step 5: Generate final code
+  - name: generate-fixed-code
+    tool: qwen_coder
+    input:
+      task: "optimize"
+      code: "${input}"
+      requirements: "Implement these verified accessibility fixes: ${verified_fixes}"
+    saveToFile: true
+    output:
+      variable: fixed_code
+
+  # Step 6: Executive Summary (using Gemini 2.5 Flash)
+  - name: executive-summary
+    tool: gemini_analyze_text
+    input:
+      text: |
+        ${a11y_scan}
+        ${wcag_standards}
+        ${proposed_fixes}
+        ${verified_fixes}
+        ${fixed_code}
+      task: |
+        Synthesize accessibility audit into executive summary:
+
+        1. Issues found (count and severity)
+        2. WCAG 2.2 compliance gaps identified
+        3. Fixes applied (summary)
+        4. Compliance level achieved
+        5. Remaining recommendations
+
+        Keep under 1500 words for Claude Code.
+    maxTokens: 5000
+    output:
+      variable: audit_summary
+
+output:
+  format: "detailed"
+  truncateSteps: false

package/workflows/code-architecture-review.yaml

@@ -0,0 +1,202 @@
+name: code-architecture-review
+description: Multi-model code architecture review with SOLID, CQRS, and best practices analysis
+version: "1.0"
+
+# Usage Examples:
+#
+# 1. With file variables (recommended):
+#    Read files and pass as variables:
+#    CODE1=$(cat src/orchestrator.ts)
+#    CODE2=$(cat src/workflows.ts)
+#    CODE3=$(cat src/types.ts)
+#
+#    Then run:
+#    workflow --name code-architecture-review \
+#      --query "Analyze architecture for SOLID compliance" \
+#      --variable "code_file_1=$CODE1" \
+#      --variable "code_file_2=$CODE2" \
+#      --variable "code_file_3=$CODE3" \
+#      --variable "file_name_1=orchestrator.ts" \
+#      --variable "file_name_2=workflows.ts" \
+#      --variable "file_name_3=types.ts"
+#
+# 2. Without files (general analysis):
+#    workflow --name code-architecture-review \
+#      --query "Compare SOLID vs CQRS patterns for workflow orchestration"
+#
+# All outputs saved to: workflow-output/code-architecture-review/{timestamp}/
+
+# Variables that can be passed:
+# - code_file_1, code_file_2, code_file_3, code_file_4, code_file_5 (file contents)
+# - file_name_1, file_name_2, file_name_3, file_name_4, file_name_5 (file names for context)
+
+steps:
+  # ═══════════════════════════════════════════════════════════════════════════
+  # ANALYSIS: Initial architecture reviews from different perspectives
+  # ═══════════════════════════════════════════════════════════════════════════
+
+  - name: grok-solid-analysis
+    tool: grok_reason
+    input:
+      problem: |
+        Original question: ${query}
+
+        Task: Analyze the code architecture for SOLID principles compliance.
+
+        ${code_file_1 ? `
+        📄 FILE: ${file_name_1 || "File 1"}
+        \`\`\`
+        ${code_file_1}
+        \`\`\`
+        ` : ""}
+
+        ${code_file_2 ? `
+        📄 FILE: ${file_name_2 || "File 2"}
+        \`\`\`
+        ${code_file_2}
+        \`\`\`
+        ` : ""}
+
+        ${code_file_3 ? `
+        📄 FILE: ${file_name_3 || "File 3"}
+        \`\`\`
+        ${code_file_3}
+        \`\`\`
+        ` : ""}
+
+        Evaluate:
+        1. Single Responsibility Principle violations
+        2. Open/Closed Principle adherence
+        3. Liskov Substitution issues
+        4. Interface Segregation opportunities
+        5. Dependency Inversion improvements
+      approach: "first-principles"
+      useHeavy: true
+    saveToFile: true
+    maxTokens: 4000
+
+  - name: gemini-pattern-analysis
+    tool: gemini_analyze_code
+    input:
+      code: |
+        Context: ${query}
+
+        Analyzing architecture patterns across these files:
+
+        ${code_file_1 ? `=== ${file_name_1 || "File 1"} ===\n${code_file_1}\n\n` : ""}
+        ${code_file_2 ? `=== ${file_name_2 || "File 2"} ===\n${code_file_2}\n\n` : ""}
+        ${code_file_3 ? `=== ${file_name_3 || "File 3"} ===\n${code_file_3}\n\n` : ""}
+      focus: "quality"
+      language: "typescript"
+    dependsOn: [grok-solid-analysis]
+    saveToFile: true
+    maxTokens: 4000
+
+  - name: qwen-cqrs-evaluation
+    tool: qwen_coder
+    input:
+      task: "review"
+      requirements: |
+        Original question: ${query}
+
+        Previous SOLID analysis: ${grok-solid-analysis.output}
+
+        Task: Evaluate CQRS pattern applicability for these files:
+
+        ${code_file_1 ? `File: ${file_name_1 || "File 1"}\n${code_file_1}\n\n` : ""}
+        ${code_file_2 ? `File: ${file_name_2 || "File 2"}\n${code_file_2}\n\n` : ""}
+        ${code_file_3 ? `File: ${file_name_3 || "File 3"}\n${code_file_3}\n\n` : ""}
+
+        Assess:
+        1. Command/Query separation opportunities
+        2. Read/Write model splitting benefits
+        3. Event sourcing applicability
+        4. Scalability improvements
+      language: "typescript"
+    loadFiles: [grok-solid-analysis]
+    dependsOn: [gemini-pattern-analysis]
+    saveToFile: true
+    maxTokens: 4000
+
+  - name: perplexity-best-practices
+    tool: perplexity_reason
+    input:
+      problem: |
+        Original question: ${query}
+
+        Context: We're analyzing code architecture. Previous analyses found:
+        - SOLID: ${grok-solid-analysis.output}
+        - Patterns: ${gemini-pattern-analysis.output}
+        - CQRS: ${qwen-cqrs-evaluation.output}
+
+        Research authoritative sources on:
+        1. Modern TypeScript architecture best practices (2024-2025)
+        2. SOLID principles in real-world applications
+        3. When CQRS is beneficial vs overkill
+        4. Code quality metrics and refactoring strategies
+      approach: "systematic"
+    loadFiles: [grok-solid-analysis, gemini-pattern-analysis, qwen-cqrs-evaluation]
+    dependsOn: [qwen-cqrs-evaluation]
+    saveToFile: true
+    maxTokens: 4000
+
+  # ═══════════════════════════════════════════════════════════════════════════
+  # REFACTORING: Concrete improvement suggestions
+  # ═══════════════════════════════════════════════════════════════════════════
+
+  - name: grok-refactoring-plan
+    tool: grok_reason
+    input:
+      problem: |
+        Original question: ${query}
+
+        Based on all previous analyses, create a prioritized refactoring plan.
+
+        SOLID issues: ${grok-solid-analysis.output}
+        Pattern opportunities: ${gemini-pattern-analysis.output}
+        CQRS evaluation: ${qwen-cqrs-evaluation.output}
+        Best practices: ${perplexity-best-practices.output}
+
+        ${code_file_1 ? `Code context: ${file_name_1 || "File 1"} + others analyzed` : ""}
+
+        Provide:
+        1. High-priority refactorings (critical issues)
+        2. Medium-priority improvements (code quality)
+        3. Low-priority enhancements (nice-to-haves)
+        4. Concrete code examples for top 3 refactorings
+      approach: "systematic"
+      useHeavy: true
+    loadFiles: [grok-solid-analysis, gemini-pattern-analysis, qwen-cqrs-evaluation, perplexity-best-practices]
+    dependsOn: [perplexity-best-practices]
+    saveToFile: true
+    maxTokens: 4000
+
+  # ═══════════════════════════════════════════════════════════════════════════
+  # CONSENSUS: Final recommendations
+  # ═══════════════════════════════════════════════════════════════════════════
+
+  - name: consensus
+    tool: openai_compare
+    input:
+      topic: "Final architecture recommendations for: ${query}"
+      options:
+        - "Grok's SOLID analysis: ${grok-solid-analysis.output}"
+        - "Gemini's pattern analysis: ${gemini-pattern-analysis.output}"
+        - "Qwen's CQRS evaluation: ${qwen-cqrs-evaluation.output}"
+        - "Perplexity's best practices: ${perplexity-best-practices.output}"
+        - "Grok's refactoring plan: ${grok-refactoring-plan.output}"
+      criteria: |
+        Evaluate based on:
+        - Technical soundness and feasibility
+        - Balance between code quality and practicality
+        - Clear, actionable recommendations
+        - Alignment with modern best practices
+      includeRecommendation: true
+    loadFiles: [grok-solid-analysis, gemini-pattern-analysis, qwen-cqrs-evaluation, perplexity-best-practices, grok-refactoring-plan]
+    dependsOn: [grok-refactoring-plan]
+    saveToFile: true
+    maxTokens: 4000
+
+output:
+  format: detailed
+  truncateSteps: false

package/workflows/code-review.yaml

@@ -0,0 +1,142 @@
+name: comprehensive-code-review
+description: Multi-perspective code review using actually registered tools
+version: "2.0"
+
+settings:
+  optimization:
+    enabled: true
+    cacheResults: true
+    compressPrompts: true
+    smartRouting: true
+
+variables:
+  severity_threshold: "medium"
+  language: "auto-detect"
+
+steps:
+  - name: initial-scan
+    tool: gemini_analyze_code  # Use Gemini for initial quick scan
+    input:
+      code: "${query}"
+      focus: general
+    saveToFile: true
+    output:
+      variable: initial_scan
+    maxTokens: 300
+
+  - name: architecture-review
+    tool: grok_code  # Grok for architecture and optimization
+    input:
+      code: "${query}"
+      task: analyze
+      requirements: |
+        Analyze architecture and code structure:
+        1. Design patterns used
+        2. Code organization
+        3. Potential optimizations
+        4. Architectural issues
+    parallel: true
+    saveToFile: true
+    output:
+      variable: architecture_analysis
+
+  - name: code-analysis
+    tool: qwen_coder  # Qwen for detailed code review
+    input:
+      code: "${query}"
+      task: review
+      language: "${language}"
+      requirements: |
+        Review code for:
+        - Syntax and structure
+        - Best practices
+        - Performance issues
+        - Potential bugs
+    parallel: true
+    saveToFile: true
+    output:
+      variable: code_issues
+
+  - name: security-research
+    tool: perplexity_ask  # Perplexity for security research
+    input:
+      query: |
+        Common security vulnerabilities in ${language} code.
+        Focus on: injection attacks, authentication, data exposure, dependency issues.
+        Provide examples and detection patterns.
+    parallel: true
+    condition:
+      failOnError: false
+    saveToFile: true
+    output:
+      variable: security_patterns
+
+  - name: readability-check
+    tool: openai_brainstorm  # OpenAI for multi-perspective readability
+    input:
+      problem: |
+        Review this code for readability and maintainability:
+        ${query}
+
+        Evaluate from 5 perspectives:
+        1. Junior developer (can they understand it?)
+        2. Senior architect (is it well-designed?)
+        3. Performance engineer (is it efficient?)
+        4. Security expert (is it safe?)
+        5. Code maintainer (is it maintainable?)
+      quantity: 5
+      style: practical
+    parallel: true
+    saveToFile: true
+    output:
+      variable: readability_review
+
+  - name: logical-flow-analysis
+    tool: grok_reason  # Grok for deep reasoning about code logic
+    input:
+      problem: |
+        Analyze the logical flow and reasoning patterns in this code:
+        ${query}
+
+        Focus on:
+        1. Control flow logic (loops, conditions, error paths)
+        2. Data transformations and state changes
+        3. Edge cases and boundary conditions
+        4. Logical correctness and potential flaws
+        5. Alternative approaches that might be clearer
+      approach: systematic
+      context: "Code review - logical flow analysis"
+    parallel: true
+    saveToFile: true
+    output:
+      variable: logical_analysis
+
+  - name: executive-summary
+    tool: gemini_analyze_text  # Gemini 2.5 Flash for large context synthesis
+    input:
+      text: |
+        ${initial_scan}
+        ${architecture_analysis}
+        ${code_issues}
+        ${security_patterns}
+        ${readability_review}
+        ${logical_analysis}
+      task: |
+        Synthesize code review into executive summary:
+
+        1. Critical issues (must fix immediately)
+        2. Important improvements (should fix soon)
+        3. Optimization opportunities
+        4. Security concerns
+        5. Logical flow issues (from deep reasoning analysis)
+        6. Code snippets for top 3 fixes
+
+        Keep under 2000 words for Claude Code.
+    maxTokens: 6000
+    output:
+      variable: review_summary
+
+output:
+  format: detailed
+  truncateSteps: false  # Show full output for all steps (no truncation)
+  # maxStepTokens: 2500  # Default if truncateSteps=true (~10k characters)