Skip to main content
Glama

MCP Think Tank

by flight505

MCP-Denkfabrik

Überblick

MCP Think Tank ist ein leistungsstarker Model Context Protocol (MCP)-Server, der die Fähigkeiten von KI-Assistenten wie Cursor und Claude @Web erweitert. Er bietet eine strukturierte Umgebung für verbessertes Denken, persistenten Speicher und verantwortungsvollen Tool-Einsatz.

Zu den wichtigsten Funktionen gehören fortschrittliches sequentielles Denken und verkettetes Denken , ein robustes Knowledge Graph Memory- System mit Versionierung und intelligente Tool-Orchestrierung mit Call-Limit-Schutzmechanismen . Diese Plattform ermöglicht es KI, komplexe Probleme durch strukturierte Analysen zu lösen, Wissen über Sitzungen hinweg aufrechtzuerhalten und externe Ressourcen wie die Websuche zu nutzen – und das alles unter Einhaltung konfigurierbarer Nutzungsbeschränkungen.

🎯 Philosophie

MCP Think Tank basiert auf drei Kernprinzipien:

  1. Elegante Einfachheit : Minimale, gut gestaltete Tools, die die KI-Funktionen ergänzen, anstatt zu versuchen, sie zu replizieren.
  2. Verbesserte Reflexion : Sanfte Anleitung fördert besseres Denken und Selbstreflexion ohne starre Einschränkungen.
  3. Persistenter Kontext : Ein einfaches, aber effektives Wissensdiagramm bietet Gedächtnis für Gespräche.

Hauptmerkmale

  • 💭 Denkwerkzeug : Spezieller Bereich für strukturiertes Denken und Selbstreflexion.
  • 🧩 Wissensgraph : Einfaches und effektives persistentes Speichersystem.
  • 📝 Tools zur Aufgabenverwaltung : Planen, verfolgen und aktualisieren Sie Aufgaben, integriert in das Wissensdiagramm.
  • 🌐 Web-Recherche-Tools (Exa) : Durchsuchen Sie das Web und erhalten Sie mithilfe der Exa-API Antworten aus Quellen.
  • 🔍 Memory Tools : Benutzerfreundliche Tools zum Speichern und Abrufen von Informationen aus dem Wissensgraphen.
  • 🤝 Client-Support : Nahtlose Integration mit Cursor, Claude @Web und anderen MCP-Clients.
  • 🛡️ Tool-Orchestrierung und Anruflimits : Integrierte Sicherheitsvorkehrungen für eine effiziente und verantwortungsvolle Tool-Nutzung mit konfigurierbaren Limits.
  • Inhalts-Caching : Leistungsoptimierung für Datei- und URL-Operationen mit automatischer Duplikatserkennung.
  • 🔄 Sequentielles Denken : Ermöglicht mehrstufige Denkprozesse mit Fortschrittsverfolgung.
  • 🔎 Selbstreflexion : Automatisierte Reflexionsdurchläufe zur Verbesserung der Argumentationsqualität.
  • 📊 Strukturierte Ausgaben : Automatische Formatierung von Denkprozessen für bessere Lesbarkeit.
  • 🔗 Forschungsintegration : Nahtlose Einbindung von Ergebnissen aus der Webrecherche in Argumentationsabläufe.

Vorteile des strukturierten Denkens

Durch die Nutzung des think wird ein spezieller Raum für systematisches Denken geschaffen, der Folgendes fördert:

  • Klare Problemdefinition
  • Relevante Kontexterfassung
  • Schritt-für-Schritt-Analyse
  • Selbstreflexion über das Denken
  • Wohlgeformte Schlussfolgerungen

Aktuelle Studien zeigen deutliche Verbesserungen durch strukturiertes Denken:

  • 54 % relative Verbesserung bei komplexen Entscheidungsaufgaben.
  • Verbesserte Konsistenz über mehrere Versuche hinweg.
  • Verbesserte Leistung bei Software-Engineering-Benchmarks.

Detaillierte Funktionen

Über die Kernliste hinaus bietet MCP Think Tank ausgefeilte Funktionen für erweiterte KI-Interaktion.

Strukturiertes Denken (Denkwerkzeug)

Das think ist der zentrale Mechanismus für fortgeschrittenes KI-Denken. Es bietet eine dedizierte, strukturierte Umgebung, in der die KI Probleme systematisch zerlegen, Kontext erfassen, Optionen analysieren und Selbstreflexion durchführen kann. Dies ermöglicht eine tiefere Analyse und qualitativ hochwertigere Ergebnisse im Vergleich zu unstrukturierten Antworten. Es unterstützt sequentielle Schritte und lässt sich nahtlos in Recherche- und Gedächtnistools integrieren.

Selbstreflexionsfunktion

Das Think-Tool enthält eine leistungsstarke Selbstreflexionsfunktion, die mit dem Parameter selfReflect: true aktiviert werden kann:

mcp_think-tool_think({ structuredReasoning: "...", selfReflect: true, reflectPrompt: "Optional custom reflection prompt" })

Bei aktivierter Selbstreflexion erhält die KI die Aufforderung, über ihre eigenen Überlegungen nachzudenken. Dies folgt der MCP-Designphilosophie, KI-Fähigkeiten zu verbessern, anstatt sie zu ersetzen.

Mit dem Parameter reflectPrompt können Sie die Eingabeaufforderung für die Reflexion anpassen und sie an bestimmte Denkaufgaben oder Domänen anpassen. Wenn dieser Parameter nicht angegeben ist, wird eine Standardeingabeaufforderung verwendet, die nach Inkonsistenzen, logischen Fehlern und Verbesserungsvorschlägen fragt.

Wissensgraph-Speicher

Der Wissensgraph bietet einen persistenten Speicher über verschiedene Interaktionen und Sitzungen hinweg. Er ermöglicht der KI, ein wachsendes Verständnis des Projekts, seiner Komponenten und der damit verbundenen Konzepte aufzubauen.

  • Mit Zeitstempel versehene Beobachtungen : Alle Speichereinträge enthalten Metadaten zur Nachverfolgung.
  • Duplikatsvermeidung : Intelligentes Entity-Matching vermeidet redundante Einträge.
  • Automatische Verknüpfung : Heuristikbasierte Beziehungserstellung verbindet verwandte Konzepte (konfigurierbar).
  • Erweiterte Abfragen : Filtern Sie Ihren Speicher nach Zeit, Tags, Schlüsselwörtern und mehr mit dem leistungsstarken Tool memory_query für historische Analysen und die Nachverfolgung der Konzeptentwicklung. Finden Sie mühelos aktuelle Einträge der letzten 48 Stunden oder eines beliebigen Zeitraums.
  • Speicherwartung : Tools zum Beschneiden und Verwalten des Speicherwachstums sind enthalten.
  • Wichtige Speichertools : Tools wie upsert_entities , add_observations , create_relations , search_nodes , memory_query und open_nodes werden zur Interaktion mit dem Diagramm verwendet.

Tools zur Aufgabenverwaltung

Mithilfe einer Reihe von Tools kann die KI Projektaufgaben direkt im Gesprächsverlauf verwalten. Dadurch werden Planung und Ausführung in den Wissensgraphen integriert, sodass die KI den Projektstatus und die Prioritäten versteht.

Wichtige Aufgabentools
  • plan_tasks : Erstellen Sie mehrere Aufgaben gleichzeitig mit Prioritäten und Abhängigkeiten
  • list_tasks : Aufgaben nach Status und Priorität filtern
  • next_task : Ruft die Aufgabe mit der höchsten Priorität ab und markiert sie als in Bearbeitung
  • complete_task : Aufgaben als erledigt markieren
  • update_tasks : Aktualisieren Sie vorhandene Aufgaben mit neuen Informationen

Web-Recherche-Tools (Exa)

MCP Think Tank nutzt die Exa-API und bietet Tools zum Abrufen externer Informationen. Dadurch kann die KI auf aktuelle Informationen aus dem Internet zugreifen, um ihre Schlussfolgerungen zu untermauern und fundierte Antworten zu liefern.

  • exa_search : Führen Sie Websuchen basierend auf einer Abfrage durch.
  • exa_answer : Erhalten Sie eine präzise, mit Quellenangaben versehene Antwort auf eine sachliche Frage.

Hinweis: Für die Verwendung dieser Tools müssen Sie Ihren Exa-API-Schlüssel konfigurieren. Weitere Informationen finden Sie im Abschnitt „Konfiguration“ .

Tool-Orchestrierung und Sicherheitsvorkehrungen

MCP Think Tank umfasst umfassende Funktionen, um sicherzustellen, dass die Tools verantwortungsvoll und effizient eingesetzt werden.

  • Nutzungslimits : Eine konfigurierbare maximale Anzahl von Tool-Aufrufen pro Benutzerinteraktion ( TOOL_LIMIT , Standard: 25). Das Limit zählt nur aufeinanderfolgende Tool-Aufrufe innerhalb einer einzelnen Benutzernachricht und wird automatisch zurückgesetzt, wenn der Benutzer eine neue Nachricht sendet.
  • Automatisches Tracking : Alle Tool-Aufrufe werden protokolliert und überwacht.
  • Graceful Degradation : Wenn Grenzwerte erreicht werden, versucht das System, Teilergebnisse zurückzugeben.
  • Intelligentes Caching : Identische Tool-Aufrufe und wiederholte Datei-/URL-Inhaltsabrufe werden automatisch zwischengespeichert, was die Ausführungszeit und den Ressourcenverbrauch reduziert. Caching-Verhalten und -Größe sind konfigurierbar ( CACHE_TOOL_CALLS , CONTENT_CACHE ).
  • Konfigurierbarer Zugriff : Durch die Whitelist von Tools können verfügbare Tools in bestimmten Kontexten eingeschränkt werden.
  • Fehlerbehandlung : Eine robuste Fehlerbehandlung bietet klares Feedback bei Problemen wie dem Erreichen von Grenzwerten oder ungültigen Toolaufrufen.

📦 Installation

⚠️ Wichtiger Hinweis LESEN SIE DIES: Wenn Sie in Cursor oder Claude auf eine neue Version von MCP Think Tank aktualisieren, erstellen Sie möglicherweise mehrere Instanzen des MCP Think Tank-Servers, wodurch zusätzliche Node.js-Instanzen erstellt werden und die Systemleistung beeinträchtigt wird. Dies ist ein bekanntes Problem bei MCP-Servern. Beenden Sie alle MCP-Think-Tank-Prozesse in Ihrem System und überprüfen Sie, ob nur eine Node.js-Instanz ausgeführt wird.

⚠️ Die Datei tasks.jsonl befindet sich in ~/.mcp-think-tank/. Die Datei ist von der kg-Datei getrennt, da der Think Tank durch zuvor erstellte Aufgaben in der kg-Datei verwirrt werden könnte. Löschen Sie den Inhalt der Datei tasks.jsonl, wenn die Datei zu groß wird oder wenn Sie ein neues Projekt starten und sicherstellen möchten, dass die Datei keine Aufgaben enthält. In einer zukünftigen Version werden Aufgaben möglicherweise mit der kg-Datei zusammengeführt, um sicherzustellen, dass abgeschlossene Aufgaben und Beziehungen im Speicher gespeichert bleiben und keine doppelten Aufgaben vorhanden sind.

NPX (empfohlen)

Der einfachste Weg, MCP Think Tank zu verwenden, ist über NPX in Cursor mithilfe der Datei mcp.json, die die neueste Version ohne globale Installation ausführt.

npx mcp-think-tank@2.0.7

Für die neueste Version (die möglicherweise Kompatibilitätsprobleme aufweist):

npx mcp-think-tank@latest

einige Benutzer haben Probleme mit npx @latest in Cursor. Versuchen Sie in diesem Fall, die Version mcp-think-tank@2.0.7 in der JSON-Datei anzugeben oder sie global zu installieren:

Globale Installation

Für ein persistentes Befehlszeilentool:

npm install -g mcp-think-tank mcp-think-tank

⚙️ Konfiguration

MCP Think Tank wird hauptsächlich über Umgebungsvariablen oder über die Konfiguration Ihres MCP-Clients (wie Cursors .cursor/mcp.json ) konfiguriert.

Schnellstart: Grundlegende Einrichtung

  1. Installieren Sie MCP Think Tank (siehe Installation oben).
  2. Holen Sie sich Ihren Exa-API-Schlüssel (erforderlich für Websuchtools):
    • Melden Sie sich bei exa.ai an und kopieren Sie Ihren API-Schlüssel.
  3. WICHTIGE STDIO-SERVER SIND VERALTET – Die MCP-Branche bewegt sich in Richtung HTTP-basierter Transporte. – ZUKÜNFTIGE UPDATES WERDEN STDIO-SERVER NICHT UNTERSTÜTZEN.
  4. Konfigurieren Sie Ihren MCP-Server (für Cursor fügen Sie ihn zu .cursor/mcp.json hinzu):
{ "mcpServers": { "think-tank": { "command": "npx", "args": ["-y", "mcp-think-tank@2.0.7"], "type": "streamable-http", "env": { "MEMORY_PATH": "/absolute/path/to/your/project/memory.jsonl", "EXA_API_KEY": "your-exa-api-key-here", } } } }

Wesentliche Variablen

  • MEMORY_PATH : Erforderlich . Absoluter Pfad zur Speicherdatei. Wichtig: Legen Sie für jedes Projekt immer einen eindeutigen MEMORY_PATH fest, um Konflikte im Wissensgraphen zwischen Projekten zu vermeiden. Falls nicht angegeben, wird standardmäßig ~/.mcp-think-tank/memory.jsonl verwendet.
  • EXA_API_KEY : Erforderlich für Exa-Websuchtools . Ihr API-Schlüssel von exa.ai.

Erweiterte Konfiguration

  • TOOL_LIMIT : Maximale Anzahl an Tool-Aufrufen pro Benutzerinteraktion (Standard: 25 ). Der Zähler wird mit jeder neuen Benutzernachricht automatisch zurückgesetzt, sodass Sie innerhalb einer Interaktion bis zu 25 aufeinanderfolgende Tool-Aufrufe durchführen können.
  • CACHE_TOOL_CALLS : Aktivieren/Deaktivieren des Caching identischer Tool-Aufrufe (Standard: true ).
  • TOOL_CACHE_SIZE : Maximale Anzahl zwischengespeicherter Tool-Aufrufe (Standard: 100 ).
  • CACHE_CONTENT : Inhaltsbasiertes Caching für Datei-/URL-Operationen aktivieren/deaktivieren (Standard: true ).
  • CONTENT_CACHE_SIZE : Maximale Anzahl von Elementen im Inhaltscache (Standard: 50 ).
  • CONTENT_CACHE_TTL : Lebensdauer des zwischengespeicherten Inhalts in Millisekunden (Standard: 300000 – 5 Minuten).
  • MCP_DEBUG : Debug-Protokollierung aktivieren (Standard: false ).
  • MCP_LISTEN_PORT : Benutzerdefinierten Port für MCP-Server festlegen (Standard: 3399 für TCP-Server, nicht relevant für stdio ).
  • LOG_LEVEL : Protokollierungsebene festlegen ( debug , info , warn , error ) (Standard: info ).
  • AUTO_LINK : Aktiviert die automatische Entitätsverknüpfung im Wissensgraphen (Standard: true ).

Speicherwartung

  • MIN_SIMILARITY_SCORE : Schwellenwert für Entitätsübereinstimmung beim Verhindern von Duplikaten (Standard: 0.85 ).
  • MAX_OPERATION_TIME : Maximale Zeit für Batch-Speicheroperationen in Millisekunden (Standard: 5000 ).

Beispielkonfiguration mit erweiterten Einstellungen in .cursor/mcp.json :

{ "mcpServers": { "think-tank": { "command": "npx", "args": ["-y", "mcp-think-tank@2.0.7"], "env": { "MEMORY_PATH": "./project-memory.jsonl", "EXA_API_KEY": "your-exa-api-key-here", "TOOL_LIMIT": "50", "CACHE_CONTENT": "true", "CONTENT_CACHE_SIZE": "100", "MCP_DEBUG": "false", "AUTO_LINK": "true" } } } }

💡 Performance-Tipp: Bei großen Projekten kann eine Erhöhung TOOL_LIMIT und Cache-Größen die Leistung verbessern, allerdings auf Kosten eines höheren Speicherverbrauchs. Beobachten Sie Ihre Nutzungsmuster und passen Sie diese entsprechend an. Im Cursor sollte das Tool-Limit jedoch 25 betragen, um ein Erreichen des Limits und die Fortsetzung vom letzten Tool-Aufruf zu vermeiden. Derzeit berichten viele Cursor-Nutzer von Problemen mit der Fortsetzung in Version 0.49.6. Dies hat nichts mit MCP Think Tank zu tun.

💡 Hinweis: Wenn Sie Cursor im YOLO-Modus oder mit Vibe-Codierung verwenden, empfehle ich, neue Chats kontextbasiert vorzubereiten und Cursor mitzuteilen, dass er den MCP Think Tank zum Erstellen von Entitäten, Beobachtungen und Beziehungen verwenden soll. So holen Sie das Beste aus dem MCP Think Tank heraus.

Ein Beispiel für Kontext-Priming ist das Speichern einer Prime.md Datei im Ordner .cursor Ihres Projekts mit dem folgenden Inhalt:

# Context Prime > Follow the instructions to understand the context of the project. ## Run the following command eza . --tree --git-ignore ## Read the following files > Read the files below to get the context of the project. > list of files: README.md ... ## MCP Think Tank Tools > Test the MCP tools, first use 'show_memory_path' to remind the user of the current memory path file used, then use the 'memory_query' tool to find and read recent entities and observations for the last 48 hours so you are up to date. > Automatically utilize the MCP Think Tank to autonomously track project context, dynamically adding entities, observations, and relations to the knowledge graph while proactively querying for relevant information and historical insights. Use integrated planning and task management tools to enhance project efficiency. Keep track of the project and its context without the user having to ask for it. > Dont do anything else.

Weitere Einzelheiten zu MCP-Servern finden Sie in der Cursor MCP-Dokumentation .

Projektregel-Setup (für Cursor/KI)

Um sicherzustellen, dass Cursor und andere kompatible Agenten die Tools von MCP Think Tank effektiv nutzen, müssen Sie die KI anleiten. Dies geschieht üblicherweise über eine Projektregel. Erstellen Sie eine einzelne Auto-Attach-Projektregel wie folgt:

1. Fügen Sie im Cursor eine neue Regel hinzu

  1. Cursor öffnen.
  2. Gehen Sie zur Befehlspalette ( Cmd+Shift+P oder Ctrl+Shift+P ).
  3. Wählen Sie „Neue Cursorregel“ aus.
  4. Benennen Sie die Regel (z. B. mcp-think-tank.mdc ).
  5. Legen Sie im Regeleditor die Metadaten fest und fügen Sie den Regelinhalt aus dem folgenden Beispiel ein.

2. Beispiel-Regeldatei ( .cursor/rules/mcp-think-tank.mdc )

Diese Markdown-Datei dient der KI als Kontext und gibt ihr Hinweise, wann und wie die verfügbaren Tools zu verwenden sind.

rule type: auto attach use globs: **/*.js,**/*.ts,**/*.jsx,**/*.tsx,**/*.md, **/*.py, **/*.json

----- Beginn der Regel -----

Regularly utilize MCP Think Tank tools to maintain an updated knowledge graph and maximize its potential. Simply call the tools in your prompt. ## Quick Decision Tree 1. 🤔 **Complex problem to analyze?** → Use `think` to structure reasoning and reflect 2. 🔍 **Need past context or information?** → Use `memory_query` (time-based) or `search_nodes` (keyword-based) 3. 📊 **Planning implementation steps?** → Use `plan_tasks` to create and track work 4. 🌐 **Need current external information?** → Use `exa_search` (general search) or `exa_answer` (factual questions) ## Critical Memory Management (Automatic Use Required) | When to automatically use memory | Tool to use | |------------------|------------| | At session start | `memory_query` with recent time filter (last 24h) | | After completing significant analysis | `upsert_entities` to store conclusions | | When context seems missing | `memory_query` with relevant keyword | | Every ~30 minutes in long sessions | `upsert_entities` to create checkpoint | | When switching between major topics | `think` + `upsert_entities` to summarize progress | | Before session end | `upsert_entities` to store session summary | ## Core Workflows ### Workflow 1: Problem Analysis → Solution 1. `memory_query` → Check for relevant past work 2. `think` → Structure reasoning about the problem 3. `plan_tasks` → Break down implementation steps 4. `upsert_entities` → Store conclusions in memory ### Workflow 2: Research → Knowledge Capture 1. `memory_query` → Check if already researched 2. `exa_search` → Find current information 3. `think` → Analyze findings 4. `upsert_entities` → Document key concepts ### Workflow 3: Context Recovery (Session Resume) 1. `memory_query` → Retrieve recent work (past 24-48h) 2. `open_nodes` → Get details on relevant entities 3. `think` → Synthesize context and plan next steps 4. Continue where left off ### Workflow 4: Task Management 1. `list_tasks` → Review current work status 2. `next_task` → Identify priority task 3. `complete_task` → Mark finished work 4. `upsert_entities` → Document completion ## Trigger Patterns (Automatic Tool Use) | When user... | Automatically use... | |--------------|----------------------| | Asks complex question requiring analysis | `think` | | Mentions "remember" or refers to past work | `memory_query` with time filter → `open_nodes` | | Uses "research" or "find latest" | `memory_query` (check if already known) → `exa_search` | | Asks factual questions needing citations | `exa_answer` | | Mentions planning or implementation | `plan_tasks` | | Refers to continuing previous work | `memory_query` → `list_tasks` → `next_task` | | Seems to have lost context from earlier | `memory_query` with recent time filter | | Makes significant conceptual progress | `upsert_entities` without being asked | | Connects related concepts | `create_relations` | | Completes major section of work | `think` + `upsert_entities` to summarize | ### When To Use Each Memory Tool - `memory_query`: For time-based searches and recent context recovery - `search_nodes`: For finding specific concepts by keyword - `open_nodes`: For retrieving full details of known entities - `upsert_entities`: For creating new knowledge or updating existing entities - `add_observations`: For adding facts to existing entities - `create_relations`: For connecting related concepts ## Other Tools Reference ### Thinking - `think`: Structured reasoning with optional reflection ### Tasks - `plan_tasks`: Create task list - `list_tasks`: View current tasks - `next_task`: Get priority task - `complete_task`: Mark task done ### Research - `exa_search`: Web search - `exa_answer`: Get cited answers ## AI Behavior Requirements 1. ALWAYS check memory at session start with `memory_query` 2. AUTOMATICALLY store important conclusions with `upsert_entities` 3. CREATE periodic memory checkpoints during long sessions 4. PROACTIVELY check memory when context seems missing 5. CHAIN tools together following the workflows 6. PRIORITIZE memory tools before web research 7. SUMMARIZE progress before ending major work segments

----- Ende der Regel -----

⚡ Leistungsoptimierung

MCP Think Tank enthält integrierte Optimierungen, um einen effizienten Betrieb zu gewährleisten:

Inhalts-Caching

  • Automatisches Caching von Datei- und URL-Inhalten basierend auf kryptografischem Hashing.
  • Verhindert redundante Dateilesevorgänge und Netzwerkanforderungen.
  • Beschleunigt wiederholte Vorgänge mit demselben Inhalt erheblich.
  • Cachegröße und TTL sind über Umgebungsvariablen ( CONTENT_CACHE_SIZE , CONTENT_CACHE_TTL ) konfigurierbar.

Tool Call Optimierung

  • Identische Toolaufrufe innerhalb einer Sitzung werden automatisch erkannt und aus einem Cache bereitgestellt.
  • Verhindert, dass doppelte Anrufe auf das Interaktionslimit angerechnet werden.
  • Verbessert die Reaktionsfähigkeit bei wiederholten Tool-Anfragen.
  • Die Cachegröße ist konfigurierbar ( TOOL_CACHE_SIZE ).

Bewährte Methoden

Für die optimale Nutzung von MCP Think Tank mit Cursor/Claude bei großen Projekten:

  • Nutzen Sie das think für alle nicht trivialen Denk- und Entscheidungsprozesse.
  • Behalten Sie wichtige Gedanken, Schlussfolgerungen und Architekturentscheidungen immer mithilfe von Speichertools im Wissensgraphen.
  • Integrieren Sie Webrecherche und Aufgabenverwaltung in Ihren Arbeitsablauf, um die KI informiert und konzentriert zu halten.
  • Überprüfen und aktualisieren Sie den Wissensgraphen Ihres Projekts regelmäßig, um seine Genauigkeit und Relevanz sicherzustellen.
  • Beziehen Sie sich auf vorhandenes Wissen und frühere Entscheidungen, um die Konsistenz in Code und Design aufrechtzuerhalten.
  • Beachten Sie die Einschränkungen bei Tool-Aufrufen, insbesondere bei komplexen automatisierten Workflows. Überwachen Sie die Nutzung gegebenenfalls.
  • Passen Sie die Konfigurationsvariablen ( TOOL_LIMIT , Cache-Einstellungen) basierend auf den Anforderungen und der Komplexität Ihres Projekts an, um eine bessere Leistung zu erzielen.

🤝 Beitragen

Beiträge sind willkommen! Senden Sie gerne einen Pull Request.

  1. Forken Sie das Repository.
  2. Erstellen Sie Ihren Feature-Zweig ( git checkout -b feature/amazing-feature ).
  3. Übernehmen Sie Ihre Änderungen ( git commit -m 'Add some amazing feature' ).
  4. Pushen Sie zum Zweig ( git push origin feature/amazing-feature ).
  5. Öffnen Sie eine Pull-Anfrage.

📄 Lizenz

Dieses Projekt ist unter der MIT-Lizenz lizenziert – Einzelheiten finden Sie in der Datei LICENSE .


Related MCP Servers

  • A
    security
    F
    license
    A
    quality
    Provides reasoning content to MCP-enabled AI clients by interfacing with Deepseek's API or a local Ollama server, enabling focused reasoning and thought process visualization.
    Last updated -
    1
    54
    24
    JavaScript
  • A
    security
    A
    license
    A
    quality
    A server that enhances Claude's reasoning capabilities by integrating DeepSeek R1's advanced reasoning engine to tackle complex reasoning tasks.
    Last updated -
    1
    Python
    MIT License
    • Apple
  • A
    security
    A
    license
    A
    quality
    Enhances AI model capabilities with structured, retrieval-augmented thinking processes that enable dynamic thought chains, parallel exploration paths, and recursive refinement cycles for improved reasoning.
    Last updated -
    1
    15
    JavaScript
    MIT License
    • Apple
  • A
    security
    A
    license
    A
    quality
    AoT MCP server enables AI models to solve complex reasoning problems by decomposing them into independent, reusable atomic units of thought, featuring a powerful decomposition-contraction mechanism that allows for deep exploration of problem spaces while maintaining high confidence in conclusions.
    Last updated -
    3
    25
    JavaScript
    MIT License
    • Apple
    • Linux

View all related MCP servers

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/flight505/mcp-think-tank'

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