Sherlock MCP para .NET

Name: dotnet-sherlock-mcp
Author: jcucci

Sherlock MCP para .NET es un servidor completo del Protocolo de Contexto de Modelo (MCP) que proporciona capacidades profundas de introspección para ensamblados .NET. Permite que los Modelos de Lenguaje (LLM) analicen y comprendan su código .NET con precisión, ofreciendo respuestas exactas y conscientes del contexto para escenarios de desarrollo complejos.

Esta herramienta es esencial para los desarrolladores que desean aprovechar las capacidades de los LLM para:

Análisis profundo del código base - Comprender arquitecturas y dependencias complejas de .NET
Información precisa de tipos - Obtener metadatos detallados sobre tipos, miembros y sus firmas
Documentación automatizada - Extraer y utilizar documentación XML y atributos
Herramientas personalizadas - Construir herramientas sofisticadas que interactúen con ensamblados .NET
Generación de código - Crear código preciso basado en estructuras de tipos existentes

Características clave

Servidor MCP completo: Proporciona más de 31 herramientas especializadas para el análisis de ensamblados .NET
Introspección avanzada de ensamblados: Análisis profundo basado en reflexión de tipos, miembros y metadatos
Análisis enriquecido de miembros: Inspección detallada de métodos, propiedades, campos, eventos y constructores
Filtrado inteligente y paginación: Filtrado avanzado por nombre/atributos con paginación eficiente para grandes conjuntos de datos
Integración de documentación XML: Extracción automática de resúmenes, parámetros, retornos y notas
Rendimiento optimizado: Caché, streaming y procesamiento eficiente de memoria
API JSON estable: Sobres consistentes con versiones y códigos de error estructurados
Nativo de .NET 9.0: Construido sobre la última plataforma .NET con características modernas de C#
Integración de proyectos: Análisis de soluciones y archivos de proyecto con resolución de dependencias

Instalación

Instale la herramienta global desde NuGet (añade sherlock-mcp a su PATH):

dotnet tool install -g Sherlock.MCP.Server

Alternativamente, durante el desarrollo puede ejecutar el servidor localmente:

dotnet run --project src/server/Sherlock.MCP.Server.csproj

Configure su cliente MCP

Sherlock se ejecuta como un servidor MCP estándar que se comunica a través de stdio.

Cursor: Settings → MCP / Custom tools → Add tool → Command: sherlock-mcp
Claude Desktop / otros clientes MCP: Añada una entrada de servidor que apunte al comando sherlock-mcp. Ejemplo de entrada JSON (consulte la documentación de su cliente para conocer la ubicación/formato exacto del archivo):

{
  "servers": {
    "sherlock": {
      "command": "sherlock-mcp"
    }
  }
}

No se requieren argumentos. El servidor se autorregistra todas las herramientas al iniciarse.

Configuración automática para proyectos .NET

Para usar Sherlock automáticamente al trabajar con código .NET, añada estas configuraciones:

Claude Code (CLAUDE.md)

Añada esto al archivo CLAUDE.md de su proyecto:

## .NET Assembly Analysis

This project uses Sherlock MCP for .NET assembly analysis. When analyzing .NET types, methods, or assemblies:

1. Use sherlock-mcp tools instead of guessing about .NET APIs
2. For type analysis: `GetTypeInfo`, `GetTypeMethods`, `GetTypeProperties`
3. For assembly overview: `AnalyzeAssembly` or `GetTypesFromAssembly`
4. For project structure: `AnalyzeProject`, `AnalyzeSolution`
5. Assembly paths are typically: `./bin/Debug/net9.0/ProjectName.dll`

Always include assembly path, prefer full type names, and use pagination for large results.

Cursor (.cursorrules)

Añada esto al archivo .cursorrules de su proyecto:

# .NET Analysis Rules
When working with .NET code, assemblies, or types:
- Use sherlock-mcp tools for accurate type/member information
- Assembly paths: ./bin/Debug/net9.0/*.dll or ./bin/Release/net9.0/*.dll
- For unknown types: GetTypesFromAssembly -> GetTypeInfo -> GetTypeMethods/Properties
- For code analysis: AnalyzeAssembly for overview, GetTypeInfo for details
- Use pagination (maxItems=50) for large results to avoid token limits

Configuración global

Para un uso en todo el sistema, añada esto a su configuración global de Claude Code o Cursor:

For .NET development: Use sherlock-mcp tools when analyzing assemblies, types, methods, or project structure. Prefer these over guessing .NET API details.

Cómo solicitarlo

A continuación, se presentan fragmentos de prompts compactos que puede pegar en su chat para ser productivo rápidamente. Ajuste las rutas a sus DLL locales.

Configuración general

You have access to an MCP server named "sherlock" that can analyze .NET assemblies. Prefer these tools for .NET questions and include short reasoning for which tool you chose. Ask me for the assembly path if missing.

Enumerar miembros de un tipo

Analyze: /absolute/path/to/MyLib/bin/Debug/net9.0/MyLib.dll
Type: MyNamespace.MyType
List methods, including non-public, filter name contains "Async", include attributes, return JSON.

Obtener documentación XML para un miembro

Use GetXmlDocsForMember on /abs/path/MyLib.dll, type MyNamespace.MyType, member TryParse. Summarize the summary + params.

Buscar tipos y profundizar

List types from /abs/path/MyLib.dll; then get type info for the first result and list its nested types.

Ajustar paginación y filtros

Use GetTypeMethods on /abs/path/MyLib.dll, type MyNamespace.MyType, sortBy name, sortOrder asc, skip 0, take 25, hasAttributeContains Obsolete.

Descripción general de las herramientas

Descubrimiento y análisis de ensamblados

AnalyzeAssembly: Descripción general completa del ensamblado con tipos públicos y metadatos
FindAssemblyByClassName: Localizar ensamblados que contienen nombres de clase específicos
FindAssemblyByFileName: Encontrar ensamblados por nombre de archivo en rutas de compilación comunes

Introspección de tipos

GetTypesFromAssembly: Listar todos los tipos públicos con metadatos (paginado)
AnalyzeType: Análisis completo de tipos con todos los miembros
GetTypeInfo: Metadatos detallados del tipo (accesibilidad, genéricos, tipos anidados)
GetTypeHierarchy: Cadena de herencia e implementaciones de interfaz
GetGenericTypeInfo: Parámetros genéricos, argumentos e información de varianza
GetTypeAttributes: Atributos personalizados declarados en tipos
GetNestedTypes: Declaraciones de tipos anidados

Análisis de miembros (filtrable y paginado)

GetAllTypeMembers: Todos los miembros en todas las categorías
GetTypeMethods: Firmas de métodos, sobrecargas y metadatos
GetTypeProperties: Detalles de propiedades, incluidos getters/setters e indexadores
GetTypeFields: Información de campos, incluidos constantes y campos de solo lectura
GetTypeEvents: Declaraciones de eventos con tipos de controlador
GetTypeConstructors: Firmas de constructores y parámetros
AnalyzeMethod: Análisis profundo de métodos con sobrecargas y atributos

Búsqueda inversa

FindImplementationsOf: Tipos que implementan una interfaz o derivan de una clase base
FindMethodsReturning: Métodos cuyo tipo de retorno coincide con un tipo dado (se admite coincidencia genérica abierta)
FindReferencesTo: Barrido más amplio a través de parámetros, campos, propiedades, eventos y argumentos genéricos

Atributos y metadatos

GetMemberAttributes: Atributos para miembros específicos
GetParameterAttributes: Información de atributos a nivel de parámetro

Documentación XML

GetXmlDocsForType: Extraer documentación XML a nivel de tipo
GetXmlDocsForMember: Documentación específica del miembro (resumen/parámetros/retornos/notas)

Análisis de proyectos y soluciones

AnalyzeSolution: Analizar archivos .sln y enumerar proyectos
AnalyzeProject: Metadatos del proyecto, referencias y configuración de compilación
GetProjectOutputPaths: Resolver directorios de salida para diferentes configuraciones
ResolvePackageReferences: Mapear paquetes NuGet a ensamblados en caché
FindDepsJsonDependencies: Analizar deps.json para dependencias en tiempo de ejecución

Configuración y tiempo de ejecución

GetRuntimeOptions: Configuración actual del servidor y valores predeterminados
UpdateRuntimeOptions: Modificar el comportamiento de paginación, caché y búsqueda

Filtrado avanzado y paginación

Todas las herramientas de análisis de miembros admiten filtrado y paginación completos:

Opciones de filtrado:

caseSensitive (bool): Coincidencia de tipo/miembro sensible a mayúsculas y minúsculas
nameContains (string): Filtrar por subcadena del nombre del miembro
hasAttributeContains (string): Filtrar por subcadena del tipo de atributo
includePublic / includeNonPublic (bool): Filtrado de visibilidad
includeStatic / includeInstance (bool): Filtrado de tipo de miembro

Paginación:

skip / take (int): Paginación de desplazamiento estándar
maxItems (int): Resultados máximos por solicitud
continuationToken (string): Paginación basada en tokens para grandes conjuntos de datos
sortBy / sortOrder (string): Ordenar por nombre/acceso en orden ascendente/descendente

Resolución de tipos:

Admite nombres completos (Namespace.Type), nombres simples (Type) y tipos anidados (Outer+Inner)
Sensibilidad a mayúsculas y minúsculas controlada por el parámetro caseSensitive
Resolución de respaldo automática para nombres de tipo ambiguos

Esquema de respuesta

Todas las herramientas devuelven un sobre JSON estable:

{ "kind": "type.list|member.methods|...", "version": "1.0.0", "data": { /* result */ } }

Los errores utilizan una forma consistente:

{ "kind": "error", "version": "1.0.0", "code": "AssemblyNotFound|TypeNotFound|InvalidArgument|InternalError", "message": "...", "details": { } }

Common error codes include `AssemblyNotFound`, `TypeNotFound`, `MemberNotFound`, `InvalidArgument`, and `InternalError`.

Contribución

Las contribuciones son bienvenidas. Este repositorio incluye un .editorconfig con preferencias modernas de C# (espacios de nombres de archivo, miembros con cuerpo de expresión, sangría de 4 espacios).

Formato de mensaje de confirmación

Este proyecto utiliza Conventional Commits para la generación automatizada de registros de cambios. Todas las confirmaciones deben seguir este formato:

type(scope): description

Tipos válidos:

feat - Una nueva característica
fix - Una corrección de errores
docs - Cambios solo en la documentación
style - Cambios en el estilo del código (formato, puntos y coma, etc.)
refactor - Cambio de código que no corrige un error ni añade una característica
perf - Mejora del rendimiento
test - Añadir o corregir pruebas
build - Cambios en el sistema de compilación o dependencias
ci - Cambios en la configuración de CI
chore - Otros cambios que no modifican archivos src o de prueba
revert - Revierte una confirmación anterior

Ejemplos:

git commit -m "feat(tools): add new assembly analysis tool"
git commit -m "fix: resolve null reference in type loader"
git commit -m "docs(readme): update installation instructions"

Configuración de desarrollo

# Restore .NET tools (versionize, husky)
dotnet tool restore

# Install git hooks for commit validation
dotnet husky install

Directrices

Mantenga los cambios pequeños y enfocados; añada pruebas unitarias para el nuevo comportamiento.
Siga las convenciones de sobre de respuesta y código de error al añadir herramientas.
Ejecute dotnet build y dotnet test localmente antes de abrir un PR.

Creación de una versión

Los mantenedores pueden crear versiones usando:

# Restore tools if not already done
dotnet tool restore

# Preview what will change
dotnet versionize --dry-run

# Create release (bumps version, updates changelog, creates git tag)
dotnet versionize

# Push changes and tag to trigger release workflow
git push --follow-tags

El flujo de trabajo de lanzamiento automáticamente:

Compilar y probar el proyecto
Crear un lanzamiento en GitHub con notas de registro de cambios
Publicar el paquete NuGet
Actualizar server.json con la nueva versión

Registro MCP

mcp-name: io.github.jcucci/dotnet-sherlock-mcp

Licencia

Sherlock MCP para .NET tiene licencia bajo la Licencia MIT.

dotnet-sherlock-mcp