Lenspr

by kyrylopr

345 downloads

Not rated

GitHub

Developer Tools

About

Code intelligence MCP server that makes AI coding safer. Builds a dependency graph of your entire codebase so Claude, Cursor, or any MCP client knows what breaks before making changes. 60+ tools for impact analysis, health scoring, dead code detection, and architecture enforcemen

Details

Author: kyrylopr
Downloads: 345
Categories: Developer Tools

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name Lenspr

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "lenspr": {
            "lenspr": {
                "command": "lenspr",
                "args": [
                    "serve",
                    "."
                ],
                "env": []
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "lenspr": {
            "lenspr": {
                "command": "lenspr",
                "args": [
                    "serve",
                    "."
                ],
                "env": []
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "lenspr": {
            "lenspr": {
                "command": "lenspr",
                "args": [
                    "serve",
                    "."
                ],
                "env": []
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "lenspr": {
            "lenspr": {
                "command": "lenspr",
                "args": [
                    "serve",
                    "."
                ],
                "env": []
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "lenspr": {
            "lenspr": {
                "command": "lenspr",
                "args": [
                    "serve",
                    "."
                ],
                "env": []
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "lenspr": {
            "lenspr": {
                "command": "lenspr",
                "args": [
                    "serve",
                    "."
                ],
                "env": []
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "lenspr": {
            "lenspr": {
                "command": "lenspr",
                "args": [
                    "serve",
                    "."
                ],
                "env": []
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "lenspr": {
            "lenspr": {
                "command": "lenspr",
                "args": [
                    "serve",
                    "."
                ],
                "env": []
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "lenspr": {
            "lenspr": {
                "command": "lenspr",
                "args": [
                    "serve",
                    "."
                ],
                "env": []
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "lenspr": {
            "lenspr": {
                "command": "lenspr",
                "args": [
                    "serve",
                    "."
                ],
                "env": []
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "lenspr": {
            "lenspr": {
                "command": "lenspr",
                "args": [
                    "serve",
                    "."
                ],
                "env": []
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "lenspr": {
            "lenspr": {
                "command": "lenspr",
                "args": [
                    "serve",
                    "."
                ],
                "env": []
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "lenspr": {
            "lenspr": {
                "command": "lenspr",
                "args": [
                    "serve",
                    "."
                ],
                "env": []
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "lenspr": {
            "lenspr": {
                "command": "lenspr",
                "args": [
                    "serve",
                    "."
                ],
                "env": []
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "lenspr": {
            "lenspr": {
                "command": "lenspr",
                "args": [
                    "serve",
                    "."
                ],
                "env": []
            }
        }
    }
}

From the repository

Install with pip install 'lenspr[all]', then run lenspr init . and lenspr setup . in your project root. Restart your IDE and your AI will have access to lens_* tools. No cloud dependency—everything runs on your machine.

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "lenspr": {
            "lenspr": {
                "command": "lenspr",
                "args": [
                    "serve",
                    "."
                ],
                "env": []
            }
        }
    }
}

McpServers

{
    "lenspr": {
        "command": "lenspr",
        "args": [
            "serve",
            "."
        ],
        "env": []
    }
}

LensPR: Safe Vibecoding. Code Intelligence for AI Agents

Your AI writes code fast. LensPR makes sure it doesn't break things along the way.

The Problem

AI coding assistants (Claude Code, Cursor, Copilot) edit one file at a time. They don't see that the function they're refactoring has 15 callers across 8 files, zero tests, and handles authentication for every endpoint in your app. They change it, something breaks three files away, and you spend an hour figuring out what went wrong.

The Solution

LensPR parses your codebase into a dependency graph and gives your AI 60+ tools to understand the full picture before making changes. One MCP call returns the function's source, all callers, all callees, related tests, and impact severity. No more blind edits.

For Vibecoders

You build fast with AI. You ship. You don't want to slow down, but you also don't want your app to quietly fall apart. LensPR is your safety net:

- Health scoring (A to F): Think of it as a fitness tracker for your codebase. See at a glance whether things are improving or degrading
- Impact analysis: Before any change, the AI sees "this function has 15 callers, 0 tests, severity: CRITICAL" and adjusts its approach
- Dead code detection: Find functions that nothing calls anymore. Stop maintaining ghost code
- NFR checks: Flags missing error handling, hardcoded secrets, endpoints without authentication
- Architecture rules: Set boundaries like "frontend must not import backend directly" and they're enforced automatically on every edit

For Teams and Professional Developers

- Cross-language tracing: Connects React frontend to API routes to database queries in one graph. From button click to DB write, visible in a single call
- Git integration at function level: Blame, history, and commit scope per function, not per file
- Refactoring support: Rename a function and update every reference across the project. Multi-file atomic changes with rollback on failure
- Architecture enforcement: Define structural rules, violations are caught before code is committed
- Session memory: Persistent notes survive context resets. Your AI picks up exactly where it left off

What Makes It Different

LensPR is not a linter. A linter says "function is too long." LensPR says "function is too long AND 15 other functions depend on it AND it has 0 tests AND it handles authentication AND if it breaks, login, registration, and every admin page stop working."

Quick Start

- pip install 'lenspr[all]'
- lenspr init .
- lenspr setup .

Restart your IDE. Your AI now has access to lens_* tools. Everything runs locally.

Your code never leaves your machine.

Supports: Python, TypeScript, JavaScript

Works with: Claude Code, Cursor, and any MCP-compatible client

License: MIT

GitHub: https://github.com/kyrylopr/lenspr

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Jump to

Setting up with Highlight

From the repository

Claude Desktop / Cursor

McpServers

Install

More like this

Sentry

Github

Git

GitLab

Context 7

Playwright