claudient 0.1.0

package/mcp/configs/postgres.json

@@ -0,0 +1,11 @@
+{
+  "mcpServers": {
+    "postgres": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-postgres", "${DATABASE_URL}"],
+      "env": {
+        "DATABASE_URL": "${DATABASE_URL}"
+      }
+    }
+  }
+}

package/mcp/de/recommended-servers.md

@@ -0,0 +1,170 @@
+> 🇩🇪 Dies ist die deutsche Übersetzung. [Englische Version](../recommended-servers.md).
+
+# MCP Empfohlene Server
+
+Ein praktischer Leitfaden zu MCP-Servern, die in Claude Code aktiviert werden sollten. Geordnet nach Kategorie mit Token-Kostenschätzungen und klarer Anleitung, wann jeder verwendet werden sollte.
+
+---
+
+## Token-Budget-Bewusstsein
+
+Jeder aktivierte MCP-Server trägt seine Tool-Beschreibungen zum Kontextfenster von Claude bei.
+
+| Aktivierte MCP-Server | Ungefähre Token-Kosten |
+|--------------------|----------------------|
+| 3 Server (~10 Tools) | ~10.000 Token |
+| 10 Server (~30 Tools) | ~30.000 Token |
+| 20 Server (~60 Tools) | ~60.000 Token |
+
+Mit einem 200k-Token-Fenster verbrauchen 10 aktive MCPs ~15% des Kontexts vor jedem Gespräch. Selektiv sein. Server deaktivieren, die nicht aktiv verwendet werden.
+
+---
+
+## Dateisystem & Suche
+
+### `@modelcontextprotocol/server-filesystem`
+```bash
+npx -y @modelcontextprotocol/server-filesystem /path/to/project
+```
+- **Was es bietet:** Dateien lesen, schreiben, auflisten und suchen mit konfigurierbaren Pfadbeschränkungen
+- **Token-Kosten:** ~2.000 Token
+- **Verwenden wenn:** Claude eine Codebase-Verzeichnisstruktur über das aktuelle Arbeitsverzeichnis hinaus erkunden soll
+- **Vermeiden wenn:** Claude Codes eingebaute Read/Write-Tools bereits das Projekt abdecken
+
+### `@modelcontextprotocol/server-brave-search` oder `tavily`
+```bash
+npx -y @modelcontextprotocol/server-brave-search
+```
+- **Was es bietet:** Websuche aus Claude heraus
+- **Token-Kosten:** ~1.500 Token
+- **Verwenden wenn:** Agenten aktuelle Informationen benötigen (Docs, Neuigkeiten, Paketversionen), die nicht in den Trainingsdaten sind
+- **Vermeiden wenn:** Nur Code-Generierung benötigt wird, keine Web-Lookups erforderlich
+
+---
+
+## Datenbanken
+
+### `@modelcontextprotocol/server-postgres`
+```json
+{
+  "mcpServers": {
+    "postgres": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://localhost/mydb"]
+    }
+  }
+}
+```
+- **Was es bietet:** Abfragen, Schema inspizieren, Tabellen auflisten — direkter DB-Zugriff aus Claude
+- **Token-Kosten:** ~3.000 Token
+- **Verwenden wenn:** Schema-Erkundung, komplexe Abfragen schreiben, Datenprobleme debuggen
+- **Vermeiden wenn:** Produktionsdatenbank — stattdessen ein schreibgeschütztes Replikat oder Dev-DB verwenden
+- **Sicherheit:** Niemals auf Produktions-DB zeigen. Mindestens einen schreibgeschützten Benutzer verwenden.
+
+### `@modelcontextprotocol/server-sqlite`
+- **Was es bietet:** Dasselbe wie postgres, aber für SQLite-Dateien
+- **Token-Kosten:** ~2.500 Token
+- **Verwenden wenn:** Lokale Entwicklung mit SQLite, eingebettete Datenbanken
+
+---
+
+## APIs & Dienste
+
+### `@modelcontextprotocol/server-github`
+```json
+{
+  "mcpServers": {
+    "github": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-github"],
+      "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "<token>" }
+    }
+  }
+}
+```
+- **Was es bietet:** Issues, PRs, Commits, Dateien aus GitHub-Repos lesen
+- **Token-Kosten:** ~4.000 Token
+- **Verwenden wenn:** PRs überprüfen, Issues priorisieren, Kontext aus Remote-Repos abrufen
+- **Vermeiden wenn:** Nur lokaler Git-Kontext benötigt wird (git CLI ist schneller)
+
+### `@modelcontextprotocol/server-linear`
+- **Was es bietet:** Linear-Issues und -Projekte erstellen, aktualisieren und abfragen
+- **Token-Kosten:** ~3.000 Token
+- **Verwenden wenn:** Issue-Tracking in den Entwicklungs-Workflow integriert ist
+
+### `stripe-mcp` (offiziell von Stripe)
+```bash
+npx -y @stripe/mcp --api-key sk_test_...
+```
+- **Was es bietet:** Kunden, Produkte, Preise, Checkout-Sessions erstellen; Zahlungen abfragen
+- **Token-Kosten:** ~5.000 Token
+- **Verwenden wenn:** Stripe-Integrationen bauen, Zahlungsflows testen
+- **Vermeiden wenn:** Produktions-Stripe-Keys — in der Entwicklung nur Testmodus verwenden
+
+---
+
+## Browser & Tests
+
+### `@modelcontextprotocol/server-puppeteer`
+- **Was es bietet:** Browser starten, Seiten navigieren, Elemente klicken, Screenshots machen
+- **Token-Kosten:** ~3.500 Token
+- **Verwenden wenn:** Web-UIs testen, Scraping, Browser-Interaktionen automatisieren
+- **Vermeiden wenn:** API-Tests — überdimensioniert, fetch/curl verwenden
+
+### `@playwright/mcp`
+```bash
+npx -y @playwright/mcp@latest
+```
+- **Was es bietet:** Playwright-Automatisierung — zuverlässiger als Puppeteer für moderne SPAs
+- **Token-Kosten:** ~4.000 Token
+- **Verwenden wenn:** E2E-Test-Schreiben, UI-Verifikation, komplexe Browser-Automatisierung
+- **Gegenüber Puppeteer empfohlen** für Next.js / React-Apps
+
+---
+
+## KI & Reasoning
+
+### `@modelcontextprotocol/server-memory`
+```bash
+npx -y @modelcontextprotocol/server-memory
+```
+- **Was es bietet:** Ein Wissensgraph, der über Sitzungen hinweg persistiert — Entitäten, Beziehungen, Beobachtungen
+- **Token-Kosten:** ~2.000 Token
+- **Verwenden wenn:** Langfristige Projekte, bei denen Claude sich Kontext zwischen Sitzungen merken soll
+- **Vermeiden wenn:** Einzel-Sitzungs-Aufgaben — Overhead ohne Nutzen
+
+### `@modelcontextprotocol/server-sequential-thinking`
+- **Was es bietet:** Erzwingt, dass Claude explizite Reasoning-Schritte durchläuft, bevor es antwortet
+- **Token-Kosten:** ~1.500 Token
+- **Verwenden wenn:** Komplexe mehrstufige Problemlösung, Architekturentscheidungen
+- **Vermeiden wenn:** Einfache Abfragen — fügt Latenz ohne Nutzen hinzu
+
+---
+
+## Konfigurationsvorlage
+
+Server zu `~/.claude/settings.json` (global) oder `.claude/settings.json` (Projekt) hinzufügen:
+
+```json
+{
+  "mcpServers": {
+    "github": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-github"],
+      "env": {
+        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
+      }
+    },
+    "postgres": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-postgres", "${DATABASE_URL}"]
+    }
+  }
+}
+```
+
+Umgebungsvariablen-Referenzen (`${VAR}`) anstelle von hartcodierten Secrets verwenden.
+
+---
+
+> **Mit uns arbeiten:** Claudient wird von [Uitbreiden](https://uitbreiden.com/) unterstützt — wir bauen KI-Produkte und B2B-Lösungen mit Entwickler-Communities. [uitbreiden.com](https://uitbreiden.com/)

package/mcp/es/recommended-servers.md

@@ -0,0 +1,170 @@
+> 🇪🇸 Esta es la traducción en español. [Versión en inglés](../recommended-servers.md).
+
+# Servidores MCP Recomendados
+
+Una guía práctica de servidores MCP que vale la pena habilitar en Claude Code. Organizados por categoría con estimaciones de costo de tokens y orientación clara sobre cuándo usar cada uno.
+
+---
+
+## Conciencia del Presupuesto de Tokens
+
+Cada servidor MCP habilitado contribuye sus descripciones de herramientas a la ventana de contexto de Claude.
+
+| Servidores MCP habilitados | Costo aproximado de tokens |
+|--------------------|----------------------|
+| 3 servidores (~10 herramientas) | ~10,000 tokens |
+| 10 servidores (~30 herramientas) | ~30,000 tokens |
+| 20 servidores (~60 herramientas) | ~60,000 tokens |
+
+Con una ventana de 200k tokens, 10 MCPs activos consumen ~15% de tu contexto antes de cualquier conversación. Sé selectivo. Deshabilita los servidores que no estés usando activamente.
+
+---
+
+## Sistema de Archivos y Búsqueda
+
+### `@modelcontextprotocol/server-filesystem`
+```bash
+npx -y @modelcontextprotocol/server-filesystem /path/to/project
+```
+- **Qué proporciona:** Leer, escribir, listar y buscar archivos con restricciones de ruta configurables
+- **Costo de tokens:** ~2,000 tokens
+- **Usar cuando:** Quieres que Claude explore un directorio del codebase más allá del directorio de trabajo actual
+- **Evitar cuando:** Las herramientas integradas de Read/Write de Claude Code ya cubren tu proyecto
+
+### `@modelcontextprotocol/server-brave-search` o `tavily`
+```bash
+npx -y @modelcontextprotocol/server-brave-search
+```
+- **Qué proporciona:** Búsqueda web desde dentro de Claude
+- **Costo de tokens:** ~1,500 tokens
+- **Usar cuando:** Los agentes necesitan información actual (docs, noticias, versiones de paquetes) no disponible en los datos de entrenamiento
+- **Evitar cuando:** Solo necesitas generación de código, sin búsquedas web necesarias
+
+---
+
+## Bases de Datos
+
+### `@modelcontextprotocol/server-postgres`
+```json
+{
+  "mcpServers": {
+    "postgres": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://localhost/mydb"]
+    }
+  }
+}
+```
+- **Qué proporciona:** Consultar, inspeccionar esquema, listar tablas — acceso directo a BD desde Claude
+- **Costo de tokens:** ~3,000 tokens
+- **Usar cuando:** Exploración de esquemas, escritura de consultas complejas, depuración de problemas de datos
+- **Evitar cuando:** Base de datos de producción — usa una réplica de solo lectura o BD de desarrollo
+- **Seguridad:** Nunca apuntes a la BD de producción. Usa un usuario de solo lectura como mínimo.
+
+### `@modelcontextprotocol/server-sqlite`
+- **Qué proporciona:** Lo mismo que postgres pero para archivos SQLite
+- **Costo de tokens:** ~2,500 tokens
+- **Usar cuando:** Desarrollo local con SQLite, bases de datos embebidas
+
+---
+
+## APIs y Servicios
+
+### `@modelcontextprotocol/server-github`
+```json
+{
+  "mcpServers": {
+    "github": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-github"],
+      "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "<token>" }
+    }
+  }
+}
+```
+- **Qué proporciona:** Leer issues, PRs, commits, archivos de repositorios de GitHub
+- **Costo de tokens:** ~4,000 tokens
+- **Usar cuando:** Revisión de PRs, triaje de issues, obtención de contexto de repos remotos
+- **Evitar cuando:** Solo necesitas contexto git local (la CLI de git es más rápida)
+
+### `@modelcontextprotocol/server-linear`
+- **Qué proporciona:** Crear, actualizar y consultar issues y proyectos de Linear
+- **Costo de tokens:** ~3,000 tokens
+- **Usar cuando:** Seguimiento de issues integrado en el flujo de trabajo de desarrollo
+
+### `stripe-mcp` (Stripe oficial)
+```bash
+npx -y @stripe/mcp --api-key sk_test_...
+```
+- **Qué proporciona:** Crear clientes, productos, precios, sesiones de checkout; consultar pagos
+- **Costo de tokens:** ~5,000 tokens
+- **Usar cuando:** Construyendo integraciones con Stripe, probando flujos de pago
+- **Evitar cuando:** Claves de Stripe de producción — usa el modo de prueba solo en desarrollo
+
+---
+
+## Navegador y Testing
+
+### `@modelcontextprotocol/server-puppeteer`
+- **Qué proporciona:** Lanzar un navegador, navegar páginas, hacer clic en elementos, tomar capturas de pantalla
+- **Costo de tokens:** ~3,500 tokens
+- **Usar cuando:** Pruebas de UIs web, scraping, automatización de interacciones del navegador
+- **Evitar cuando:** Pruebas de API — es excesivo, usa fetch/curl
+
+### `@playwright/mcp`
+```bash
+npx -y @playwright/mcp@latest
+```
+- **Qué proporciona:** Automatización con Playwright — más fiable que Puppeteer para SPAs modernas
+- **Costo de tokens:** ~4,000 tokens
+- **Usar cuando:** Escritura de pruebas E2E, verificación de UI, automatización compleja del navegador
+- **Recomendado sobre Puppeteer** para aplicaciones Next.js / React
+
+---
+
+## IA y Razonamiento
+
+### `@modelcontextprotocol/server-memory`
+```bash
+npx -y @modelcontextprotocol/server-memory
+```
+- **Qué proporciona:** Un grafo de conocimiento que persiste entre sesiones — entidades, relaciones, observaciones
+- **Costo de tokens:** ~2,000 tokens
+- **Usar cuando:** Proyectos de larga duración donde quieres que Claude recuerde el contexto entre sesiones
+- **Evitar cuando:** Tareas de una sola sesión — sobrecarga sin beneficio
+
+### `@modelcontextprotocol/server-sequential-thinking`
+- **Qué proporciona:** Obliga a Claude a pasar por pasos de razonamiento explícito antes de responder
+- **Costo de tokens:** ~1,500 tokens
+- **Usar cuando:** Resolución de problemas complejos de múltiples pasos, decisiones arquitectónicas
+- **Evitar cuando:** Consultas simples — agrega latencia sin beneficio
+
+---
+
+## Plantilla de Configuración
+
+Agrega servidores a `~/.claude/settings.json` (global) o `.claude/settings.json` (proyecto):
+
+```json
+{
+  "mcpServers": {
+    "github": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-github"],
+      "env": {
+        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
+      }
+    },
+    "postgres": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-postgres", "${DATABASE_URL}"]
+    }
+  }
+}
+```
+
+Usa referencias a variables de entorno (`${VAR}`) en lugar de secretos hardcodeados.
+
+---
+
+> **Trabaja con nosotros:** Claudient está respaldado por [Uitbreiden](https://uitbreiden.com/) — construimos productos de IA y soluciones B2B con comunidades de desarrolladores. [uitbreiden.com](https://uitbreiden.com/)

package/mcp/fr/recommended-servers.md

@@ -0,0 +1,170 @@
+> 🇫🇷 This is the French translation. [English version](../recommended-servers.md).
+
+# Serveurs MCP Recommandés
+
+Un guide pratique des serveurs MCP valant la peine d'être activés dans Claude Code. Organisé par catégorie avec des estimations du coût en tokens et des conseils clairs sur quand utiliser chacun.
+
+---
+
+## Sensibilisation au Budget de Tokens
+
+Chaque serveur MCP activé contribue ses descriptions d'outils à la fenêtre de contexte de Claude.
+
+| Serveurs MCP activés | Coût approximatif en tokens |
+|---------------------|----------------------------|
+| 3 serveurs (~10 outils) | ~10 000 tokens |
+| 10 serveurs (~30 outils) | ~30 000 tokens |
+| 20 serveurs (~60 outils) | ~60 000 tokens |
+
+Avec une fenêtre de 200k tokens, 10 MCPs actifs consomment ~15% de votre contexte avant toute conversation. Soyez sélectif. Désactivez les serveurs que vous n'utilisez pas activement.
+
+---
+
+## Système de Fichiers & Recherche
+
+### `@modelcontextprotocol/server-filesystem`
+```bash
+npx -y @modelcontextprotocol/server-filesystem /path/to/project
+```
+- **Ce qu'il apporte :** Lire, écrire, lister et rechercher des fichiers avec des restrictions de chemin configurables
+- **Coût en tokens :** ~2 000 tokens
+- **Utiliser quand :** Vous voulez que Claude explore un répertoire de base de code au-delà du répertoire de travail actuel
+- **Éviter quand :** Les outils intégrés Read/Write de Claude Code couvrent déjà votre projet
+
+### `@modelcontextprotocol/server-brave-search` ou `tavily`
+```bash
+npx -y @modelcontextprotocol/server-brave-search
+```
+- **Ce qu'il apporte :** Recherche web depuis Claude
+- **Coût en tokens :** ~1 500 tokens
+- **Utiliser quand :** Les agents ont besoin d'informations actuelles (docs, actualités, versions de packages) non présentes dans les données d'entraînement
+- **Éviter quand :** Vous n'avez besoin que de génération de code, pas de recherches web
+
+---
+
+## Bases de Données
+
+### `@modelcontextprotocol/server-postgres`
+```json
+{
+  "mcpServers": {
+    "postgres": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://localhost/mydb"]
+    }
+  }
+}
+```
+- **Ce qu'il apporte :** Requêter, inspecter le schéma, lister les tables — accès DB direct depuis Claude
+- **Coût en tokens :** ~3 000 tokens
+- **Utiliser quand :** Exploration de schéma, rédaction de requêtes complexes, débogage de problèmes de données
+- **Éviter quand :** Base de données de production — utiliser un replica en lecture seule ou une DB de dev
+- **Sécurité :** Ne jamais pointer vers la DB de production. Utiliser un utilisateur en lecture seule au minimum.
+
+### `@modelcontextprotocol/server-sqlite`
+- **Ce qu'il apporte :** Identique à postgres mais pour les fichiers SQLite
+- **Coût en tokens :** ~2 500 tokens
+- **Utiliser quand :** Développement local avec SQLite, bases de données embarquées
+
+---
+
+## APIs & Services
+
+### `@modelcontextprotocol/server-github`
+```json
+{
+  "mcpServers": {
+    "github": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-github"],
+      "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "<token>" }
+    }
+  }
+}
+```
+- **Ce qu'il apporte :** Lire les issues, PRs, commits, fichiers depuis des dépôts GitHub
+- **Coût en tokens :** ~4 000 tokens
+- **Utiliser quand :** Révision de PRs, triage d'issues, récupération de contexte depuis des dépôts distants
+- **Éviter quand :** Vous n'avez besoin que du contexte git local (le CLI git est plus rapide)
+
+### `@modelcontextprotocol/server-linear`
+- **Ce qu'il apporte :** Créer, mettre à jour et interroger les issues et projets Linear
+- **Coût en tokens :** ~3 000 tokens
+- **Utiliser quand :** Suivi des issues intégré dans le workflow de développement
+
+### `stripe-mcp` (Stripe officiel)
+```bash
+npx -y @stripe/mcp --api-key sk_test_...
+```
+- **Ce qu'il apporte :** Créer des customers, produits, prix, sessions checkout ; interroger les paiements
+- **Coût en tokens :** ~5 000 tokens
+- **Utiliser quand :** Construction d'intégrations Stripe, test des flux de paiement
+- **Éviter quand :** Clés Stripe de production — utiliser uniquement le mode test en développement
+
+---
+
+## Navigateur & Tests
+
+### `@modelcontextprotocol/server-puppeteer`
+- **Ce qu'il apporte :** Lancer un navigateur, naviguer sur des pages, cliquer sur des éléments, prendre des captures d'écran
+- **Coût en tokens :** ~3 500 tokens
+- **Utiliser quand :** Tests d'UI web, scraping, automatisation d'interactions navigateur
+- **Éviter quand :** Tests API — surdimensionné, utiliser fetch/curl
+
+### `@playwright/mcp`
+```bash
+npx -y @playwright/mcp@latest
+```
+- **Ce qu'il apporte :** Automatisation Playwright — plus fiable que Puppeteer pour les SPAs modernes
+- **Coût en tokens :** ~4 000 tokens
+- **Utiliser quand :** Rédaction de tests E2E, vérification UI, automatisation complexe de navigateur
+- **Recommandé plutôt que Puppeteer** pour les applications Next.js / React
+
+---
+
+## IA & Raisonnement
+
+### `@modelcontextprotocol/server-memory`
+```bash
+npx -y @modelcontextprotocol/server-memory
+```
+- **Ce qu'il apporte :** Un graphe de connaissances qui persiste entre les sessions — entités, relations, observations
+- **Coût en tokens :** ~2 000 tokens
+- **Utiliser quand :** Projets long-running où vous voulez que Claude se souvienne du contexte entre les sessions
+- **Éviter quand :** Tâches à session unique — surcoût sans bénéfice
+
+### `@modelcontextprotocol/server-sequential-thinking`
+- **Ce qu'il apporte :** Force Claude à travers des étapes de raisonnement explicites avant de répondre
+- **Coût en tokens :** ~1 500 tokens
+- **Utiliser quand :** Résolution de problèmes multi-étapes complexes, décisions architecturales
+- **Éviter quand :** Requêtes simples — ajoute de la latence sans bénéfice
+
+---
+
+## Template de Configuration
+
+Ajouter des serveurs à `~/.claude/settings.json` (global) ou `.claude/settings.json` (projet) :
+
+```json
+{
+  "mcpServers": {
+    "github": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-github"],
+      "env": {
+        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
+      }
+    },
+    "postgres": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-postgres", "${DATABASE_URL}"]
+    }
+  }
+}
+```
+
+Utiliser des références à des variables d'environnement (`${VAR}`) plutôt que des secrets codés en dur.
+
+---
+
+> **Travaillez avec nous :** Claudient est soutenu par [Uitbreiden](https://uitbreiden.com/) — nous construisons des produits IA et des solutions B2B avec des communautés de développeurs. [uitbreiden.com](https://uitbreiden.com/)

package/mcp/nl/recommended-servers.md

@@ -0,0 +1,170 @@
+> 🇳🇱 Dit is de Nederlandse vertaling. [Engelse versie](../recommended-servers.md).
+
+# MCP Aanbevolen Servers
+
+Een praktische gids voor MCP-servers die het waard zijn om in Claude Code in te schakelen. Georganiseerd per categorie met tokenkostraming en duidelijke richtlijnen over wanneer elke te gebruiken.
+
+---
+
+## Token Budget Bewustzijn
+
+Elke ingeschakelde MCP-server draagt zijn toolbeschrijvingen bij aan het contextvenster van Claude.
+
+| Ingeschakelde MCP-servers | Geschatte tokenkosten |
+|--------------------|----------------------|
+| 3 servers (~10 tools) | ~10.000 tokens |
+| 10 servers (~30 tools) | ~30.000 tokens |
+| 20 servers (~60 tools) | ~60.000 tokens |
+
+Met een 200k tokenvenster verbruiken 10 actieve MCP's ~15% van je context voor elk gesprek. Wees selectief. Schakel servers uit die je niet actief gebruikt.
+
+---
+
+## Bestandssysteem & Zoeken
+
+### `@modelcontextprotocol/server-filesystem`
+```bash
+npx -y @modelcontextprotocol/server-filesystem /path/to/project
+```
+- **Wat het biedt:** Bestanden lezen, schrijven, weergeven en zoeken met configureerbare padrestricties
+- **Tokenkosten:** ~2.000 tokens
+- **Gebruik wanneer:** Je wilt dat Claude een codebasedirectory verkent buiten de huidige werkmap
+- **Vermijd wanneer:** Claude Code's ingebouwde Read/Write-tools al je project afdekken
+
+### `@modelcontextprotocol/server-brave-search` of `tavily`
+```bash
+npx -y @modelcontextprotocol/server-brave-search
+```
+- **Wat het biedt:** Webzoeken vanuit Claude
+- **Tokenkosten:** ~1.500 tokens
+- **Gebruik wanneer:** Agenten actuele informatie nodig hebben (documentatie, nieuws, pakketversies) die niet in trainingsdata zit
+- **Vermijd wanneer:** Je alleen codegeneratie nodig hebt, geen webzoekopdrachten
+
+---
+
+## Databases
+
+### `@modelcontextprotocol/server-postgres`
+```json
+{
+  "mcpServers": {
+    "postgres": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://localhost/mydb"]
+    }
+  }
+}
+```
+- **Wat het biedt:** Query's uitvoeren, schema inspecteren, tabellen weergeven — directe DB-toegang vanuit Claude
+- **Tokenkosten:** ~3.000 tokens
+- **Gebruik wanneer:** Schema-exploratie, complexe queries schrijven, dataproblemen debuggen
+- **Vermijd wanneer:** Productiedatabase — gebruik een alleen-lezen replica of dev-DB
+- **Beveiliging:** Wijs nooit naar productie-DB. Gebruik minimaal een alleen-lezen gebruiker.
+
+### `@modelcontextprotocol/server-sqlite`
+- **Wat het biedt:** Hetzelfde als postgres maar voor SQLite-bestanden
+- **Tokenkosten:** ~2.500 tokens
+- **Gebruik wanneer:** Lokale ontwikkeling met SQLite, ingebedde databases
+
+---
+
+## API's & Services
+
+### `@modelcontextprotocol/server-github`
+```json
+{
+  "mcpServers": {
+    "github": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-github"],
+      "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "<token>" }
+    }
+  }
+}
+```
+- **Wat het biedt:** Issues, PR's, commits, bestanden lezen vanuit GitHub-repo's
+- **Tokenkosten:** ~4.000 tokens
+- **Gebruik wanneer:** PR's reviewen, issues triagen, context ophalen vanuit externe repo's
+- **Vermijd wanneer:** Je alleen lokale git-context nodig hebt (git CLI is sneller)
+
+### `@modelcontextprotocol/server-linear`
+- **Wat het biedt:** Linear-issues en -projecten aanmaken, bijwerken en bevragen
+- **Tokenkosten:** ~3.000 tokens
+- **Gebruik wanneer:** Issue-tracking geïntegreerd in ontwikkelingsworkflow
+
+### `stripe-mcp` (Stripe officieel)
+```bash
+npx -y @stripe/mcp --api-key sk_test_...
+```
+- **Wat het biedt:** Klanten, producten, prijzen, checkout-sessies aanmaken; betalingen bevragen
+- **Tokenkosten:** ~5.000 tokens
+- **Gebruik wanneer:** Stripe-integraties bouwen, betalingsflows testen
+- **Vermijd wanneer:** Productie Stripe-sleutels — gebruik testmodus alleen in ontwikkeling
+
+---
+
+## Browser & Testen
+
+### `@modelcontextprotocol/server-puppeteer`
+- **Wat het biedt:** Een browser starten, pagina's navigeren, elementen klikken, schermafbeeldingen maken
+- **Tokenkosten:** ~3.500 tokens
+- **Gebruik wanneer:** Web-UI's testen, scrapen, browserinteracties automatiseren
+- **Vermijd wanneer:** API-testen — overkill, gebruik fetch/curl
+
+### `@playwright/mcp`
+```bash
+npx -y @playwright/mcp@latest
+```
+- **Wat het biedt:** Playwright-automatisering — betrouwbaarder dan Puppeteer voor moderne SPA's
+- **Tokenkosten:** ~4.000 tokens
+- **Gebruik wanneer:** E2E-tests schrijven, UI-verificatie, complexe browserautomatisering
+- **Aanbevolen boven Puppeteer** voor Next.js / React-apps
+
+---
+
+## AI & Redenering
+
+### `@modelcontextprotocol/server-memory`
+```bash
+npx -y @modelcontextprotocol/server-memory
+```
+- **Wat het biedt:** Een kennisgraaf die persisteert over sessies — entiteiten, relaties, observaties
+- **Tokenkosten:** ~2.000 tokens
+- **Gebruik wanneer:** Langlopende projecten waarbij je wilt dat Claude context onthoudt tussen sessies
+- **Vermijd wanneer:** Enkelvoudige sessietaken — overhead zonder voordeel
+
+### `@modelcontextprotocol/server-sequential-thinking`
+- **Wat het biedt:** Dwingt Claude door expliciete redenerstappen voor het beantwoorden
+- **Tokenkosten:** ~1.500 tokens
+- **Gebruik wanneer:** Complexe meerstaps probleemoplossing, architectuurbeslissingen
+- **Vermijd wanneer:** Eenvoudige queries — voegt latentie toe zonder voordeel
+
+---
+
+## Configuratiesjabloon
+
+Voeg servers toe aan `~/.claude/settings.json` (globaal) of `.claude/settings.json` (project):
+
+```json
+{
+  "mcpServers": {
+    "github": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-github"],
+      "env": {
+        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
+      }
+    },
+    "postgres": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-postgres", "${DATABASE_URL}"]
+    }
+  }
+}
+```
+
+Gebruik omgevingsvariabele-verwijzingen (`${VAR}`) in plaats van hardcoded secrets.
+
+---
+
+> **Werk met ons:** Claudient wordt ondersteund door [Uitbreiden](https://uitbreiden.com/) — we bouwen AI-producten en B2B-oplossingen met ontwikkelaarsgemeenschappen. [uitbreiden.com](https://uitbreiden.com/)