Loading ToolBench
The AI Acceleration & MCP Suite for Go - provides native MCP tools, prompts, and dynamic resources to accelerate Go development, static AST inspection, database schema exploration, and runtime diagnostics.
go-boost provides 17 well-intentioned tools for Go project analysis with mostly complete schemas and descriptions. However, several tools lack parameter descriptions, some descriptions are generic or under-specified, and output schemas are not documented. Tool naming is generally clear (verb_noun pattern: app_info, ast_inspect, route_list, db_schema, security_scan, deadcode_detect, concurrency_check, find_implementations, mock_generate, read_logs, last_error, diagnose_run, openapi_generate). Most tools are READ_ONLY with clear risk classification. Key gaps: (1) db_schema, db_query, schema_struct_diff, migration_generate lack parameter descriptions for 'connection' and 'filter' fields; (2) no output schemas documented for any tool, LLMs cannot plan downstream calls; (3) error handling is minimal, no recovery guidance or actionable error messages visible; (4) some descriptions are vague (e.g., 'Analyze Go code for concurrency hazards' lacks specifics on what hazards are detected). Baseline: avg tool description ~194 chars; go-boost descriptions range 80 - 250 chars, mostly adequate but some lack context on WHEN to use the tool.
Get comprehensive Go application information including Go version, module name, detected web framework, ORM, database engine, logger, architecture pattern, and all installed packages with exact versions. Always call this tool when starting work on a Go project.
Deep static AST inspection of Go files or packages. Extracts all structs, interfaces, methods, comments, and field tags (json, gorm, db, validate) without executing code. Highly useful for understanding data models and contracts.
Analyze Go code for concurrency hazards: mutex leaks, data races, goroutine leaks, and unsafe channel operations. Uses static analysis without executing code.
List configured database connection names and parameters detected from .env and config files.
Execute a strictly read-only SQL query against the configured database (e.g. SELECT, SHOW, EXPLAIN, DESCRIBE, PRAGMA). Mutations like INSERT, UPDATE, DELETE, and DROP are strictly blocked.
No output schemas documented for any tool. LLMs cannot infer what fields to expect, forcing them to guess at response structure and breaking tool chaining. E.g., app_info returns JSON but structure is undocumented; ast_inspect returns symbols but field names are unknown.
Parameter descriptions missing or incomplete for db_schema, db_query, schema_struct_diff, migration_generate. The 'connection' parameter lacks guidance on how to discover available connection names; 'filter' in db_schema is vague ('Filter tables by name (substring match)', does it match table name, column name, or both?).
Inferred effective spec: <=2025-11-25.
| Scored | Grade | Overall | Spec posture | Rubric |
|---|---|---|---|---|
| 2026-09-23 | D | 58 | <=2025-11-25 | v2 |
Inspect the database schema. Returns table names, columns, indexes, and foreign keys. Use 'summary: true' first to get a quick overview of tables and column types, then call again with 'filter' for full details on specific tables.
Detect unused structs, interfaces, functions, methods, and constants in the codebase. Helps identify dead code for cleanup.
Execute a command (e.g. 'go test', 'make build') with timeout and capture full output. Useful for running diagnostics, tests, and builds within the MCP context.
Find all types that implement a given interface. Returns struct names, their packages, and method signatures.
Extract and return the most recent error from application logs with full context (timestamp, stack trace if available, surrounding log entries).
Generate SQL migration files (up/down) from detected schema-struct differences. Creates timestamped migration files in the migrations directory.
Generate a pure-Go unit test mock struct that implements a given interface. Includes all methods with stub implementations and a call tracker.
Generate an OpenAPI 3.0 specification (JSON) from detected HTTP routes. Includes paths, methods, and basic request/response schemas inferred from handlers.
Read and parse application log files (supports JSON, structured, and plain text formats). Returns the most recent log entries.
Scan Go codebase AST for all registered HTTP routes across Gin, Echo, Fiber, Chi, and Go 1.22+ net/http pattern routes. Returns methods, path patterns, handlers, and source locations.
Compare database schema against Go struct definitions. Detects missing columns, type mismatches, and orphaned fields. Useful for identifying schema-code drift before migrations.
Audit codebase for SQL injection vulnerabilities, hardcoded secrets (API keys, passwords, tokens), TLS/HTTPS misconfigurations, and insecure cryptography. Scans AST and string literals.
No error handling guidance visible in tool definitions. Tools like db_query, diagnose_run, and migration_generate can fail (missing DB client, command timeout, permission denied) but descriptions do not explain recovery steps or error categories (retryable vs. fatal).
Destructive tools (migration_generate, diagnose_run) lack confirmation or dry-run support. An LLM could accidentally generate and apply a migration or execute a destructive command without user approval.
Vague descriptions for analysis tools. concurrency_check says 'Analyze Go code for concurrency hazards' but does not specify which hazards (mutex leaks, data races, goroutine leaks, unsafe channels), LLMs cannot determine if this tool will detect their specific concern.