Sherlock MCP für .NET

Sherlock MCP für .NET ist ein umfassender Model Context Protocol (MCP)-Server, der tiefgreifende Introspektionsfunktionen für .NET-Assemblies bietet. Er ermöglicht es Large Language Models (LLMs), Ihren .NET-Code präzise zu analysieren und zu verstehen, um genaue und kontextbezogene Antworten für komplexe Entwicklungsszenarien zu liefern.

Dieses Tool ist unverzichtbar für Entwickler, die LLM-Funktionen für folgende Zwecke nutzen möchten:

• Tiefe Codebasis-Analyse - Verständnis komplexer .NET-Architekturen und Abhängigkeiten

• Präzise Typinformationen - Detaillierte Metadaten über Typen, Member und deren Signaturen erhalten

• Automatisierte Dokumentation - Extrahieren und Nutzen von XML-Dokumentationen und Attributen

• Benutzerdefinierte Tooling-Lösungen - Entwicklung anspruchsvoller Tools, die mit .NET-Assemblies interagieren

• Codegenerierung - Erstellung präzisen Codes basierend auf bestehenden Typstrukturen

Hauptfunktionen

• Umfassender MCP-Server: Bietet über 31 spezialisierte Tools für die Analyse von .NET-Assemblies

• Erweiterte Assembly-Introspektion: Tiefgreifende, auf Reflection basierende Analyse von Typen, Membern und Metadaten

• Umfangreiche Member-Analyse: Detaillierte Untersuchung von Methoden, Eigenschaften, Feldern, Ereignissen und Konstruktoren

• Intelligente Filterung & Paginierung: Erweiterte Filterung nach Namen/Attributen mit effizienter Paginierung für große Datensätze

• XML-Dokumentationsintegration: Automatische Extraktion von Zusammenfassungen, Parametern, Rückgabewerten und Anmerkungen

• Leistungsoptimiert: Caching, Streaming und speichereffiziente Verarbeitung

• Stabile JSON-API: Konsistente Envelopes mit Versionierung und strukturierten Fehlercodes

• .NET 9.0 Native: Auf der neuesten .NET-Plattform mit modernen C#-Funktionen aufgebaut

• Projektintegration: Analyse von Projekt- und Solution-Dateien mit Abhängigkeitsauflösung

Installation

Installieren Sie das globale Tool von NuGet (fügt sherlock-mcp zu Ihrem PATH hinzu):

dotnet tool install -g Sherlock.MCP.Server

Alternativ können Sie den Server während der Entwicklung lokal ausführen:

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

Konfigurieren Sie Ihren MCP-Client

Sherlock läuft als Standard-MCP-Server, der über stdio kommuniziert.

• Cursor: Einstellungen → MCP / Benutzerdefinierte Tools → Tool hinzufügen → Befehl: sherlock-mcp

• Claude Desktop / andere MCP-Clients: Fügen Sie einen Servereintrag hinzu, der auf den Befehl sherlock-mcp verweist. Beispiel-JSON-Eintrag (siehe Dokumentation Ihres Clients für den genauen Dateipfad/das Format):

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

Es sind keine Argumente erforderlich. Der Server registriert beim Start alle Tools automatisch.

Automatische Konfiguration für .NET-Projekte

Um Sherlock bei der Arbeit mit .NET-Code automatisch zu verwenden, fügen Sie diese Konfigurationen hinzu:

Claude Code (CLAUDE.md)

Fügen Sie dies zur CLAUDE.md-Datei Ihres Projekts hinzu:

## .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)

Fügen Sie dies zur .cursorrules-Datei Ihres Projekts hinzu:

# .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

Globale Konfiguration

Für die systemweite Nutzung fügen Sie dies zu Ihren globalen Claude Code-Einstellungen oder der Cursor-Konfiguration hinzu:

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

So verwenden Sie Prompts

Nachfolgend finden Sie kompakte Prompt-Snippets, die Sie in Ihren Chat kopieren können, um schnell produktiv zu werden. Passen Sie die Pfade an Ihre lokalen DLLs an.

Allgemeine Einrichtung

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.

Member für einen Typ auflisten

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.

XML-Dokumentation für ein Member abrufen

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

Typen finden und Details untersuchen

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

Paging und Filter anpassen

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

Tool-Übersicht

Assembly-Erkennung & Analyse

• AnalyzeAssembly: Vollständiger Assembly-Überblick mit öffentlichen Typen und Metadaten

• FindAssemblyByClassName: Assemblies finden, die bestimmte Klassennamen enthalten

• FindAssemblyByFileName: Assemblies anhand des Dateinamens in gängigen Build-Pfaden finden

Typ-Introspektion

• GetTypesFromAssembly: Alle öffentlichen Typen mit Metadaten auflisten (paginiert)

• AnalyzeType: Umfassende Typanalyse mit allen Membern

• GetTypeInfo: Detaillierte Typ-Metadaten (Zugriffsberechtigung, Generics, verschachtelte Typen)

• GetTypeHierarchy: Vererbungskette und Schnittstellenimplementierungen

• GetGenericTypeInfo: Generische Parameter, Argumente und Varianzinformationen

• GetTypeAttributes: Benutzerdefinierte Attribute, die für Typen deklariert sind

• GetNestedTypes: Deklarationen verschachtelter Typen

Member-Analyse (filterbar & paginiert)

• GetAllTypeMembers: Alle Member über alle Kategorien hinweg

• GetTypeMethods: Methodensignaturen, Überladungen und Metadaten

• GetTypeProperties: Eigenschaftsdetails einschließlich Getter/Setter und Indexer

• GetTypeFields: Feldinformationen einschließlich Konstanten und schreibgeschützter Felder

• GetTypeEvents: Ereignisdeklarationen mit Handler-Typen

• GetTypeConstructors: Konstruktorsignaturen und Parameter

• AnalyzeMethod: Tiefe Methodenanalyse mit Überladungen und Attributen

Rückwärtssuche

• FindImplementationsOf: Typen, die eine Schnittstelle implementieren oder von einer Basisklasse erben

• FindMethodsReturning: Methoden, deren Rückgabetyp mit einem bestimmten Typ übereinstimmt (Open-Generic-Übereinstimmung unterstützt)

• FindReferencesTo: Breitere Suche über Parameter, Felder, Eigenschaften, Ereignisse und generische Argumente

Attribute & Metadaten

• GetMemberAttributes: Attribute für bestimmte Member

• GetParameterAttributes: Attributinformationen auf Parameterebene

XML-Dokumentation

• GetXmlDocsForType: XML-Dokumentation auf Typ-Ebene extrahieren

• GetXmlDocsForMember: Member-spezifische Dokumentation (Zusammenfassung/Parameter/Rückgabewerte/Anmerkungen)

Projekt- & Solution-Analyse

• AnalyzeSolution: .sln-Dateien parsen und Projekte auflisten

• AnalyzeProject: Projekt-Metadaten, Referenzen und Build-Konfiguration

• GetProjectOutputPaths: Ausgabeverzeichnisse für verschiedene Konfigurationen auflösen

• ResolvePackageReferences: NuGet-Pakete auf zwischengespeicherte Assemblies abbilden

• FindDepsJsonDependencies: deps.json für Laufzeitabhängigkeiten parsen

Konfiguration & Laufzeit

• GetRuntimeOptions: Aktuelle Serverkonfiguration und Standardwerte

• UpdateRuntimeOptions: Paginierung, Caching und Suchverhalten ändern

Erweiterte Filterung & Paginierung

Alle Member-Analyse-Tools unterstützen umfassende Filterung und Paginierung:

Filteroptionen:

• caseSensitive (bool): Groß-/Kleinschreibung bei der Typ-/Member-Übereinstimmung

• nameContains (string): Filtern nach Teilstring des Member-Namens

• hasAttributeContains (string): Filtern nach Teilstring des Attributtyps

• includePublic / includeNonPublic (bool): Sichtbarkeitsfilterung

• includeStatic / includeInstance (bool): Member-Typ-Filterung

Paginierung:

• skip / take (int): Standard-Offset-Paginierung

• maxItems (int): Maximale Ergebnisse pro Anfrage

• continuationToken (string): Token-basierte Paginierung für große Datensätze

• sortBy / sortOrder (string): Sortierung nach Name/Zugriff in aufsteigender/absteigender Reihenfolge

Typauflösung:

• Unterstützt vollständige Namen (Namespace.Type), einfache Namen (Type) und verschachtelte Typen (Outer+Inner)

• Groß-/Kleinschreibung wird durch den Parameter caseSensitive gesteuert

• Automatische Fallback-Auflösung für mehrdeutige Typnamen

Antwort-Schema

Alle Tools geben einen stabilen JSON-Envelope zurück:

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

Fehler verwenden eine konsistente Form:

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

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

Mitwirken

Beiträge sind willkommen. Dieses Repo enthält eine .editorconfig mit modernen C#-Präferenzen (file-scoped namespaces, expression-bodied members, 4-Leerzeichen-Einrückung).

Commit-Nachrichtenformat

Dieses Projekt verwendet Conventional Commits für die automatisierte Changelog-Generierung. Alle Commits müssen diesem Format folgen:

type(scope): description

Gültige Typen:

• feat - Ein neues Feature

• fix - Ein Bugfix

• docs - Nur Dokumentationsänderungen

• style - Änderungen am Codestil (Formatierung, Semikolons, etc.)

• refactor - Codeänderung, die weder einen Bug behebt noch ein Feature hinzufügt

• perf - Leistungsverbesserung

• test - Hinzufügen oder Korrigieren von Tests

• build - Änderungen am Build-System oder an Abhängigkeiten

• ci - Änderungen an der CI-Konfiguration

• chore - Andere Änderungen, die keine Quell- oder Testdateien modifizieren

• revert - Macht einen vorherigen Commit rückgängig

Beispiele:

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"

Entwicklungseinrichtung

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

# Install git hooks for commit validation
dotnet husky install

Richtlinien

• Halten Sie Änderungen klein und fokussiert; fügen Sie Unit-Tests für neues Verhalten hinzu.

• Befolgen Sie die Konventionen für Antwort-Envelopes und Fehlercodes beim Hinzufügen von Tools.

• Führen Sie dotnet build und dotnet test lokal aus, bevor Sie einen PR öffnen.

Erstellen eines Releases

Maintainer können Releases wie folgt erstellen:

# 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

Der Release-Workflow wird automatisch:

1. Das Projekt bauen und testen

2. Ein GitHub-Release mit Changelog-Notizen erstellen

3. Das NuGet-Paket veröffentlichen

4. server.json mit der neuen Version aktualisieren

MCP-Registry

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

Lizenz

Sherlock MCP für .NET ist unter der MIT-Lizenz lizenziert.