Which integrations are available for this server?

Provides tools for monitoring and analyzing local application log files with real-time tailing, error tracking, log search capabilities, and server status monitoring Enables monitoring of Node.js application logs including Winston, Pino, and Bunyan log formats with real-time tailing and error detection Supports parsing and monitoring of Pino log files with search and real-time monitoring capabilities

How do I use Local Logs MCP Server?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Local Logs MCP Server show me the last 10 errors from my Node.js app" 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.

Local Logs MCP Server

by mariosss

Overview Schema Related Servers Score Discussions

JavaScript

Local

Local Logs MCP Server

A Model Context Protocol (MCP) server for monitoring local application logs with real-time tailing, error tracking, and log search capabilities.

Perfect for monitoring Node.js applications, web servers, or any application that writes to log files.

License Node Version

✨ Features

📁 Log File Discovery - Automatically finds and lists available log files
📜 Real-time Log Tailing - Get the last N lines from any log file
⚠️ Error Monitoring - Quickly check error logs for issues
📊 Server Status - Get server status summary from log analysis
👀 Log Watching - Monitor log files for changes
🔍 Log Search - Search for specific text patterns in logs
🔧 Configurable - Supports custom log directories and file extensions
🚀 Easy Setup - Works with Cursor, Claude Desktop, VS Code Copilot, and more

Related MCP server: Local Lens

🛠️ Available Tools

Tool	Description	Parameters
`get_log_files`	List available log files with metadata	None
`tail_log`	Get last N lines from a log file	`filename`, `lines`
`get_errors`	Get recent error log entries	`lines`
`get_server_status`	Server status summary from logs	None
`watch_log`	Monitor log file for changes	`filename`
`search_logs`	Search for text in log files	`query`, `filename`, `lines`

📦 Installation

🚀 One-Command Setup (Recommended)

Linux/Mac:

curl -sSL https://raw.githubusercontent.com/mariosss/local-logs-mcp-server/main/install-new.js | node

Windows (PowerShell):

Invoke-WebRequest -Uri "https://raw.githubusercontent.com/mariosss/local-logs-mcp-server/main/install-new.js" | Invoke-Expression

That's it! The installation script will download the server file directly and configure Cursor automatically. Just restart Cursor and you're ready to go!

Alternative: Two-Command Setup

npm install -g https://github.com/mariosss/local-logs-mcp-server
local-logs-setup

Alternative: Manual Setup

npm install -g local-logs-mcp-server
local-logs-setup

NPX Usage (No Installation)

npx local-logs-mcp-server

Manual Installation

git clone https://github.com/mariosss/local-logs-mcp-server.git
cd local-logs-mcp-server
npm install -g .

⚙️ Configuration

✅ Automatic Configuration (Default)

The package automatically configures Cursor for you! No manual setup needed.

🔧 Manual Configuration (If needed)

For Cursor IDE

Add to your .cursor/mcp.json (project-specific) or global MCP config:

{
  "mcpServers": {
    "local-logs": {
      "command": "npx",
      "args": ["-y", "local-logs-mcp-server"],
      "env": {
        "LOGS_DIR": "./logs"
      }
    }
  }
}

For Claude Desktop

Add to your Claude Desktop MCP config (~/Library/Application Support/Claude/claude_desktop_config.json on Mac):

{
  "mcpServers": {
    "local-logs": {
      "command": "npx",
      "args": ["-y", "local-logs-mcp-server"],
      "env": {
        "LOGS_DIR": "/path/to/your/logs"
      }
    }
  }
}

For VS Code (GitHub Copilot)

Add to your .vscode/mcp.json:

{
  "servers": {
    "local-logs": {
      "command": "npx",
      "args": ["-y", "local-logs-mcp-server"],
      "env": {
        "LOGS_DIR": "./logs"
      }
    }
  }
}

For Windsurf (Codium)

Add to your Windsurf MCP config:

{
  "mcpServers": {
    "local-logs": {
      "command": "npx",
      "args": ["-y", "local-logs-mcp-server"],
      "env": {
        "LOGS_DIR": "./logs"
      }
    }
  }
}

🔧 Environment Variables

Variable	Description	Default
`LOGS_DIR`	Directory containing log files	Auto-detected (see below)
`LOG_EXTENSIONS`	Comma-separated log file extensions	`.log,.txt`

Log Directory Auto-Detection

If LOGS_DIR is not specified, the server automatically searches for logs in this priority order:

./logs (current directory)
./apps/backend/logs (monorepo structure)
./server/logs (server directory)
./backend/logs (backend directory)
/var/log (system logs on Linux/Mac)
C:\logs (system logs on Windows)

📋 Usage Examples

Once configured with your MCP client, you can use natural language commands:

Basic Commands

"Check my server logs"
"Are there any errors in the logs?"
"What's my server status?"
"Show me available log files"

Advanced Commands

"Show me the last 50 lines from error.log"
"Search logs for 'database connection'"
"Monitor access.log for changes"
"Find all log entries containing 'TypeError'"

🏗️ Project Structure Examples

Standard Node.js Project

your-project/
├── logs/
│   ├── combined.log    # Main application log
│   ├── error.log      # Error log
│   └── access.log     # Access log (optional)
├── .cursor/
│   └── mcp.json       # MCP configuration
├── src/
└── package.json

Monorepo Structure

your-monorepo/
├── apps/
│   └── backend/
│       └── logs/
│           ├── combined.log
│           └── error.log
├── .cursor/
│   └── mcp.json
└── package.json

🔍 Supported Log Formats

The server works with any text-based log files and can parse:

Winston logs (JSON and text format)
Morgan access logs
Pino logs
Bunyan logs
Custom application logs
System logs
Any .log or .txt files

Example Log Formats

Winston Text Format:

2024-01-15 10:30:45 [INFO]: Server started on port 3000
2024-01-15 10:30:50 [ERROR]: Database connection failed

Winston JSON Format:

{"level":"info","message":"Server started","timestamp":"2024-01-15T10:30:45.123Z"}
{"level":"error","message":"Database connection failed","timestamp":"2024-01-15T10:30:50.456Z"}

🛡️ Security

Read-only access - Server only reads log files, never writes or modifies
Directory scoping - Only accesses files in the specified logs directory
No network access - Operates entirely on local files
Permission respect - Respects file system permissions

🚀 Performance

Efficient file reading - Uses streaming for large log files
Memory conscious - Doesn't load entire files into memory
Fast search - Optimized text search algorithms
Minimal dependencies - Only uses Node.js built-in modules

🤝 Contributing

Fork the repository
Create your feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🐛 Troubleshooting

Server shows red/error status

Check that the logs directory exists and is accessible
Verify log files have proper read permissions
Ensure Node.js version is 14 or higher
Check that the server path is correct in your MCP config

No tools available

Restart your MCP client (Cursor, Claude, VS Code)
Verify MCP configuration syntax is valid JSON
Check that the MCP server is responding (test with echo '{"jsonrpc":"2.0","method":"initialize","id":1}' | npx local-logs-mcp-server)

Log files not found

Set the correct LOGS_DIR environment variable
Make sure your application is actually writing to log files
Check that file extensions match LOG_EXTENSIONS setting
Verify directory permissions allow reading

Common Log Directory Issues

Issue: "Logs directory not found"

# Solution: Set explicit path
export LOGS_DIR="/path/to/your/logs"

Issue: "No log files found"

# Solution: Check file extensions
export LOG_EXTENSIONS=".log,.txt,.out"

📚 Examples

Complete Cursor Setup

Install globally:
```
npm install -g local-logs-mcp-server
```

Add to .cursor/mcp.json:

{
  "mcpServers": {
    "local-logs": {
      "command": "local-logs-mcp",
      "env": {
        "LOGS_DIR": "./logs"
      }
    }
  }
}

Restart Cursor and test:
- Ask: "Check my server logs"

Complete Claude Desktop Setup

Open Claude Desktop config:

# Mac
open ~/Library/Application\ Support/Claude/claude_desktop_config.json

# Windows
notepad %APPDATA%\Claude\claude_desktop_config.json

Add configuration:

{
  "mcpServers": {
    "local-logs": {
      "command": "npx",
      "args": ["-y", "local-logs-mcp-server"],
      "env": {
        "LOGS_DIR": "/Users/yourusername/projects/myapp/logs"
      }
    }
  }
}

Restart Claude Desktop

Made with ❤️ for the MCP community

Available Tools

6 tools

get_errorsC

Get recent error log entries

ParametersJSON Schema

Name	Required	Description	Default
`lines`	No	Number of error lines to return (default: 20)

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves 'recent error log entries', implying a read-only operation, but doesn't clarify aspects like rate limits, authentication needs, or whether it accesses live or archived logs. This leaves significant gaps in understanding the tool's behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence with zero waste—'Get recent error log entries'—front-loading the core purpose without unnecessary details. It's appropriately sized for a simple tool with one optional parameter.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the lack of annotations and output schema, the description is incomplete for a log retrieval tool. It doesn't explain the return format (e.g., structured data vs. raw text), error handling, or how 'recent' is defined, which are critical for an agent to use it effectively in context with sibling tools.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage, with the 'lines' parameter clearly documented in the schema itself. The description adds no additional meaning beyond what the schema provides, such as explaining what 'recent' means or how entries are ordered. Baseline 3 is appropriate since the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose with a specific verb ('Get') and resource ('recent error log entries'), making it immediately understandable. However, it doesn't differentiate from sibling tools like 'get_log_files' or 'search_logs', which likely access similar log data, so it doesn't fully distinguish its specific scope.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives like 'get_log_files' or 'search_logs'. It lacks context about prerequisites, such as whether it requires specific permissions or if it's intended for real-time monitoring versus historical analysis, leaving the agent to guess based on tool names alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_log_filesB

Get list of available log files with metadata

ParametersJSON Schema

Name	Required	Description	Default
No parameters

TDQS

B3.1/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states it retrieves a list with metadata, implying a read-only operation, but doesn't specify details like pagination, rate limits, authentication needs, or what metadata is included. This is a significant gap for a tool with zero annotation coverage.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that directly states the tool's purpose without any fluff or redundancy. It is appropriately sized and front-loaded, making it easy for an agent to parse quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the lack of annotations and output schema, the description is incomplete. It doesn't explain what the return values look like (e.g., format of the list or metadata), behavioral traits, or how it differs from siblings. For a tool with no structured data support, this leaves critical gaps for agent understanding.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 0 parameters with 100% coverage, so no parameter information is needed. The description appropriately doesn't discuss parameters, and the baseline score is 4 for tools with zero parameters, as it avoids unnecessary details.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'Get' and the resource 'list of available log files with metadata', which is specific and actionable. However, it doesn't explicitly differentiate from sibling tools like 'search_logs' or 'tail_log', which likely have overlapping log-related purposes.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives like 'search_logs' or 'tail_log'. It lacks context about use cases, prerequisites, or exclusions, leaving the agent to infer usage from the tool name alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_server_statusB

Get server status summary from logs

ParametersJSON Schema

Name	Required	Description	Default
No parameters

TDQS

B3.1/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action ('Get') but doesn't reveal any behavioral traits such as read-only vs. destructive nature, authentication requirements, rate limits, or what the 'summary' entails. This leaves significant gaps for a tool that interacts with logs.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that directly states the tool's purpose without any unnecessary words. It is front-loaded and wastes no space, making it highly concise and well-structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity of interacting with server logs and the lack of annotations and output schema, the description is insufficient. It doesn't explain what 'status summary' includes, how it's derived from logs, or the return format, leaving the agent with incomplete context for effective use.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately doesn't add parameter details, and the baseline for this scenario is 4, as it avoids redundancy while being complete for a parameterless tool.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb ('Get') and resource ('server status summary from logs'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_errors' or 'search_logs', which might also retrieve log-related information, preventing a perfect score.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives like 'get_errors' or 'search_logs'. It lacks context about use cases, prerequisites, or exclusions, leaving the agent with minimal direction for tool selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

search_logsC

Search for specific text in log files

ParametersJSON Schema

Name	Required	Description	Default
`query`	Yes	Text to search for in logs
`filename`	No	Log file to search (default: combined.log)	combined.log
`lines`	No	Number of matching lines to return (default: 10)

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It states the action ('search') but doesn't disclose behavioral traits like whether this is a read-only operation (implied but not stated), performance characteristics, rate limits, authentication needs, or what happens when no matches are found. For a search tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized for a straightforward search tool and front-loaded with the core functionality. Every word earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's moderate complexity (search with filtering), lack of annotations, and no output schema, the description is incomplete. It doesn't explain return values (e.g., format of results, error handling), behavioral constraints, or how it differs from sibling tools. For a search operation with multiple parameters and no structured output documentation, more context is needed.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents all three parameters (query, filename, lines) with descriptions and defaults. The description adds no additional parameter semantics beyond what's in the schema, such as search syntax (e.g., regex support) or filename constraints. Baseline 3 is appropriate when schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb ('search') and resource ('log files') with specificity about searching for 'specific text'. It distinguishes from siblings like 'get_log_files' (list files) and 'tail_log' (stream recent entries), but doesn't explicitly differentiate from 'get_errors' which might also search logs. Purpose is clear but sibling differentiation could be more explicit.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus alternatives like 'get_errors' (which might filter for errors), 'tail_log' (for real-time monitoring), or 'watch_log' (for continuous watching). The description provides basic functionality but no context about appropriate use cases or exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

tail_logA

Get the last N lines from a log file

ParametersJSON Schema

Name	Required	Description	Default
`filename`	No	Name of the log file (default: combined.log)	combined.log
`lines`	No	Number of lines to return (default: 50)

TDQS

A3.5/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden but only states the basic function. It doesn't disclose behavioral traits such as whether this requires file read permissions, if it handles large files efficiently, potential rate limits, or error behavior for missing files. The description is minimal and lacks operational context.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that directly states the tool's purpose with zero wasted words. It's appropriately sized for a simple tool and front-loaded with essential information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple read operation with no annotations and no output schema, the description is minimally adequate but incomplete. It doesn't explain what the output looks like (e.g., raw text, structured data), error conditions, or performance characteristics, leaving gaps in operational understanding.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema fully documents both parameters (filename and lines) with descriptions and defaults. The description adds no additional parameter semantics beyond what the schema provides, meeting the baseline for high schema coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the specific action ('Get the last N lines') and resource ('from a log file'), distinguishing it from siblings like get_log_files (list files), search_logs (search content), and watch_log (continuous monitoring). It precisely defines the tool's function without ambiguity.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for retrieving recent log entries, but provides no explicit guidance on when to use this tool versus alternatives like search_logs (for specific patterns) or get_errors (for error-focused retrieval). It lacks clear when-not-to-use statements or prerequisites.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

watch_logC

Monitor a log file for changes

ParametersJSON Schema

Name	Required	Description	Default
`filename`	No	Name of the log file to monitor (default: combined.log)	combined.log

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden for behavioral disclosure. 'Monitor a log file for changes' implies an ongoing or real-time operation but doesn't specify whether this is a blocking call, how changes are detected, what format output takes, or any rate limits. The description is too vague about actual behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence with zero wasted words. It's appropriately sized for a simple tool and front-loads the core functionality immediately.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a monitoring tool with no annotations and no output schema, the description is inadequate. It doesn't explain what 'monitor' means operationally, what constitutes 'changes', how results are returned, or how this differs from similar sibling tools. The agent would struggle to use this effectively.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage, with the single parameter 'filename' well-documented in the schema. The description adds no additional parameter semantics beyond what's already in the schema, so the baseline score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('monitor') and resource ('log file for changes'), making the purpose immediately understandable. However, it doesn't differentiate this tool from sibling tools like 'tail_log' or 'search_logs', which likely have overlapping functionality with log monitoring.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives like 'tail_log' or 'search_logs'. It doesn't specify whether this is for real-time monitoring, periodic checking, or other specific contexts, leaving the agent with no usage differentiation.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A3.5/5.0

Disambiguation5/5

Each tool has a clearly distinct purpose with no overlap: get_errors retrieves error entries, get_log_files lists files, get_server_status provides a summary, search_logs finds text, tail_log gets last lines, and watch_log monitors changes. The descriptions reinforce these unique functions, making tool selection unambiguous.

Naming Consistency5/5

All tool names follow a consistent verb_noun pattern using snake_case, such as get_errors, search_logs, and tail_log. This uniformity makes the set predictable and easy to understand, with no deviations in naming style.

Tool Count5/5

With 6 tools, the server is well-scoped for log management, covering essential operations like listing, searching, tailing, and monitoring logs. Each tool earns its place without being excessive or insufficient for the domain.

Completeness4/5

The tool set provides strong coverage for log reading and monitoring, including search, tail, and watch functionalities. A minor gap exists in write operations (e.g., clearing or modifying logs), but agents can effectively work with the provided read-only tools for typical log analysis tasks.

Maintenance

ActivityInactive

ResponsivenessNo issues

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Auralogs
ai.auralogs
Read-only access to Auralogs production logs: search logs, inspect errors, review AI analyses.
Observability Monitoring
2
Superlog
sh.superlog
Open-source agent that observes and fixes your application. Query logs, traces, metrics, incidents.
Monitoring Observability
21,039
Raygun
io.github.MindscapeHQ
Investigate errors, track deployments, analyze performance, and manage application monitoring
Monitoring Observability
222
Foam Observability
io.github.foam-ai
Query application logs, traces, and metrics from your AI coding assistant via Foam's MCP server.
Observability Monitoring Developer Tools
2

Related MCP Servers

Log MCP Server
Monitoring Developer Tools
thhart
A
license
A
quality
C
maintenance
Enables AI assistants to automatically inspect and analyze application runtime log files for debugging and troubleshooting. Supports monitoring multiple log directories simultaneously with tools for listing, reading, searching, and paginating through log files.
Updated 9 months ago (2025-12-11 20:32 UTC)
8
MIT
Local Lens
Monitoring Developer Tools
aotakeda
A
license
Not graded
quality
D
maintenance
A 100% local development monitoring tool that captures browser console logs, network requests, and backend server output for analysis by AI assistants via MCP. It enables LLMs to debug applications by providing structured, real-time access to full-stack log data and persistent local storage.
Updated a year ago (2025-07-14 23:56 UTC)
13
7
MIT
LogScribe MCP
Observability Monitoring
haramrit09k
F
license
Not graded
quality
D
maintenance
Handles log file management and analysis with tools to list, read, search, filter, and generate analytics on log files.
Updated a year ago (2025-06-09 05:45 UTC)
1
mcp-log-analyzer
Monitoring Version Control Autonomous Agents
mashish
A
license
Not graded
quality
D
maintenance
Analyzes log files locally using Ollama and files structured GitHub Issues automatically, with all processing kept on your machine.
Updated 6 months ago (2026-03-11 22:04 UTC)
1
MIT

Appeared in Searches

MCP server for executing CLI commands and managing development servers

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/mariosss/local-logs-mcp-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server

Local Logs MCP Server

✨ Features

🛠️ Available Tools

📦 Installation

🚀 One-Command Setup (Recommended)

Alternative: Two-Command Setup

Alternative: Manual Setup

NPX Usage (No Installation)

Manual Installation

⚙️ Configuration

✅ Automatic Configuration (Default)

🔧 Manual Configuration (If needed)

For Cursor IDE

For Claude Desktop

For VS Code (GitHub Copilot)

For Windsurf (Codium)

🔧 Environment Variables

Log Directory Auto-Detection

📋 Usage Examples

Basic Commands

Advanced Commands

🏗️ Project Structure Examples

Standard Node.js Project

Monorepo Structure

🔍 Supported Log Formats

Example Log Formats

🛡️ Security

🚀 Performance

🤝 Contributing

📄 License

🐛 Troubleshooting

Server shows red/error status

No tools available

Log files not found

Common Log Directory Issues

📚 Examples

Complete Cursor Setup

Complete Claude Desktop Setup

🔗 Related Projects

Available Tools

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Related MCP Servers

Appeared in Searches

Latest Blog Posts

MCP directory API