Enables on-demand code coverage report generation for analysis of test coverage metrics
Supports configuration through environment variables for customizing log analysis behavior
Integrates with GitHub Actions for CI workflows and test validation
Allows deployment and version management of the MCP server through the Python Package Index
Click on "Deploy 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., "@Log Analyzer MCP analyze the last hour of application logs for errors"
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.
Log Analyzer MCP is a powerful Python-based toolkit designed to streamline the way you interact with log files. Whether you're debugging complex applications, monitoring test runs, or simply trying to make sense of verbose log outputs, this tool provides both a Command-Line Interface (CLI) and a Model-Context-Protocol (MCP) server to help you find the insights you need, quickly and efficiently.
Why use Log Analyzer MCP?
Simplify Log Analysis: Cut through the noise with flexible parsing, advanced filtering (time-based, content, positional), and configurable context display.
Integrate with Your Workflow: Use it as a standalone loganalyzer CLI tool for scripting and direct analysis, or integrate the MCP server with compatible clients like Cursor for an AI-assisted experience.
Extensible and Configurable: Define custom log sources, patterns, and search scopes to tailor the analysis to your specific needs.
Related MCP server: Log Analyzer MCP Server
Core Log Analysis Engine: Robust backend for parsing and searching various log formats.
loganalyzer CLI: Intuitive command-line tool for direct log interaction.
MCP Server: Exposes log analysis capabilities to MCP clients, enabling features like:
Test log summarization (analyze_tests).
Execution of test runs with varying verbosity.
Targeted unit test execution (run_unit_test).
On-demand code coverage report generation (create_coverage_report).
Advanced log searching: all records, time-based, first/last N records.
Hatch Integration: For easy development, testing, and dependency management.
This package can be installed from PyPI (once published) or directly from a local build for development purposes.
Once the package is published to PyPI.
pip install log-analyzer-mcpThis will install the loganalyzer CLI tool and make the MCP server package available for integration.
If you have cloned the repository and want to use your local changes:
Ensure Hatch is installed. (See Developer Guide)
Build the package:
hatch build This creates wheel and sdist packages in the dist/ directory.
Install the local build into your Hatch environment (or any other virtual environment):
Replace <version> with the actual version from the generated wheel file (e.g., 0.2.7).
# If using Hatch environment:
hatch run pip uninstall log-analyzer-mcp -y && hatch run pip install dist/log_analyzer_mcp-<version>-py3-none-any.whl
# For other virtual environments:
# pip uninstall log-analyzer-mcp -y # (If previously installed)
# pip install dist/log_analyzer_mcp-<version>-py3-none-any.whlFor IDEs like Cursor to pick up changes to the MCP server, you may need to manually reload the server in the IDE. See the Developer Guide for details.
There are two primary ways to use Log Analyzer MCP:
As a Command-Line Tool (loganalyzer):
Ideal for direct analysis, scripting, or quick checks.
Requires Python 3.9+.
For installation, see the Installation section above.
For detailed usage, see the CLI Usage Guide (upcoming) or the API Reference for CLI commands.
As an MCP Server (e.g., with Cursor):
Integrates log analysis capabilities directly into your AI-assisted development environment.
For installation, see the Installation section. The MCP server component is included when you install the package.
For configuration with a client like Cursor and details on running the server, see Configuring and Running the MCP Server below and the Developer Guide.
Configuration of the Log Analyzer MCP (for both CLI and Server) is primarily handled via environment variables or a .env file in your project root.
Environment Variables: Set variables like LOG_DIRECTORIES, LOG_PATTERNS_ERROR, LOG_CONTEXT_LINES_BEFORE, LOG_CONTEXT_LINES_AFTER, etc., in the environment where the tool or server runs.
.env File: Create a .env file by copying .env.template (this template file needs to be created and added to the repository) and customize the values.
For a comprehensive list of all configuration options and their usage, please refer to the (Upcoming) Configuration Guide.
(Note: The .env.template file should be created and added to the repository to provide a starting point for users.)
The MCP server can be launched in several ways:
Via an MCP Client (e.g., Cursor):
Configure your client to launch the log-analyzer-mcp executable (often using a helper like uvx). This is the typical way to integrate the server.
Example Client Configuration (e.g., in .cursor/mcp.json):
{
"mcpServers": {
"log_analyzer_mcp_server_prod": {
"command": "uvx", // uvx is a tool to run python executables from venvs
"args": [
"log-analyzer-mcp" // Fetches and runs the latest version from PyPI
// Or, for a specific version: "log-analyzer-mcp==0.2.0"
],
"env": {
"PYTHONUNBUFFERED": "1",
"PYTHONIOENCODING": "utf-8",
"MCP_LOG_LEVEL": "INFO", // Recommended for production
// "MCP_LOG_FILE": "/path/to/your/logs/mcp/log_analyzer_mcp_server.log", // Optional
// --- Configure Log Analyzer specific settings via environment variables ---
// These are passed to the analysis engine used by the server.
// Example: "LOG_DIRECTORIES": "[\"/path/to/your/app/logs\"]",
// Example: "LOG_PATTERNS_ERROR": "[\"Exception:.*\"]"
// (Refer to the (Upcoming) docs/configuration.md for all options)
}
}
// You can add other MCP servers here
}
}Notes:
Replace placeholder paths and consult the Getting Started Guide, the (Upcoming) Configuration Guide, and the Developer Guide for more on configuration options and environment variables.
The actual package name on PyPI is log-analyzer-mcp.
Directly (for development/testing):
You can run the server directly using its entry point if needed. The log-analyzer-mcp command (available after installation) can be used:
log-analyzer-mcp --transport http --port 8080
# or for stdio transport
# log-analyzer-mcp --transport stdio Refer to log-analyzer-mcp --help for more options. For development, using Hatch scripts defined in pyproject.toml or the methods described in the Developer Guide is also common.
API Reference: Detailed reference for MCP server tools and CLI commands.
Getting Started Guide: For users and integrators. This guide provides a general overview.
Developer Guide: For contributors, covering environment setup, building, detailed testing procedures (including coverage checks), and release guidelines.
(Upcoming) Configuration Guide: Detailed explanation of all .env and environment variable settings. (This document needs to be created.)
(Upcoming) CLI Usage Guide: Comprehensive guide to all loganalyzer commands and options. (This document needs to be created.)
.env.template: A template file for configuring environment variables. (This file needs to be created and added to the repository.)
Refactoring Plan: Technical details on the ongoing evolution of the project.
To run tests and generate coverage reports, please refer to the comprehensive Testing Guidelines in the Developer Guide. This section covers using hatch test, running tests with coverage, generating HTML reports, and targeting specific tests.
We welcome contributions! Please see CONTRIBUTING.md and the Developer Guide for guidelines on how to set up your environment, test, and contribute.
Log Analyzer MCP is licensed under the MIT License with Commons Clause. See LICENSE.md for details.
Analyze the most recent test run and provide detailed information about failures.
Args:
summary_only: Whether to return only a summary of the test results
Inputs: summary_only. Returns: object
Run the coverage report script and generate HTML and XML reports.
Args:
force_rebuild: Whether to force rebuilding the report even if it exists
Returns:
Dictionary containing execution results and report paths
Inputs: force_rebuild. Returns: object
Returns sys.path and sys.executable from the running MCP server.
Inputs: no named parameters. Returns: object
Check if the MCP server is alive.
Inputs: no named parameters. Returns: result
Run all tests with minimal output (verbosity level 0).
Inputs: no named parameters. Returns: object
Run all tests with verbose output (verbosity level 1).
Inputs: no named parameters. Returns: object
Run all tests with very verbose output (verbosity level 2).
Inputs: no named parameters. Returns: object
Run tests for a specific agent only.
This tool runs tests that match the agent's patterns including both main agent tests
and healthcheck tests, significantly reducing test execution time compared to running all tests.
Use this tool when you need to focus on testing a specific agent component.
Args:
agent: The agent to run tests for (e.g., 'qa_agent', 'backlog_agent')
verbosity: Verbosity level (0=minimal, 1=normal, 2=detailed), default is 1
Returns:
Dictionary containing test results and analysis
Inputs: agent (required), verbosity. Returns: object
Search for all log records, optionally filtering by scope and content patterns, with context.
Inputs: scope, context_before, context_after, log_dirs_override, +1 more. Returns: result
Search for the first N (oldest) records, optionally filtering, with context.
Inputs: count (required), scope, context_before, context_after, +2 more. Returns: result
Search for the last N (newest) records, optionally filtering, with context.
Inputs: count (required), scope, context_before, context_after, +2 more. Returns: result
Search logs within a time window, optionally filtering, with context.
Inputs: minutes, hours, days, scope, +4 more. Returns: result
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 12 tools
There is significant overlap between the test-running tools (run_tests_no_verbosity, run_tests_verbose, run_tests_very_verbose, run_unit_test) which could cause confusion about which to select for different verbosity needs. However, the search_log_* tools are well-differentiated by their temporal focus, and analyze_tests vs. create_coverage_report serve distinct purposes.
Most tools follow a consistent verb_noun pattern (analyze_tests, create_coverage_report, search_log_all_records, etc.). The main deviation is get_server_env_details which uses a get_ prefix instead of a more descriptive verb, and ping which is a single word outlier, but overall the naming is quite predictable.
12 tools is reasonable for a log analyzer server that also handles testing. While the count is appropriate, the distribution feels slightly imbalanced with many test-running tools and fewer log analysis tools, but it's still within a well-scoped range.
For log analysis, the search tools provide good temporal coverage but lack operations like log ingestion, filtering by severity, or aggregation. For testing, there are multiple execution tools but no tools for test setup, teardown, or result comparison. The surface covers core workflows but has notable gaps in both domains.
MCP server for AI dialogue using various LLM models via AceDataCloud
MCP server for building and testing AI agents with multi-model experimentation and insights.
MCP server that lets your AI assistant build and deploy apps, hosting each one at a live URL.
Cloud-hosted MCP server for durable AI memory
