### Install MCP Profiler Bundle

Source: https://github.com/killerwolf/mcp-profiler-bundle/blob/main/README.md

Installs the MCP Profiler Bundle using Composer. This is the primary method for adding the bundle to your Symfony project.

```bash
composer require killerwolf/mcp-profiler-bundle:^0.1
```

--------------------------------

### MCP Profiler Template Example

Source: https://github.com/killerwolf/mcp-profiler-bundle/blob/main/Resources/docs/data_collector.md

A basic Twig template for displaying the data collected by the MCPDataCollector in the Symfony profiler.

```twig
{% extends '@WebProfiler/Profiler/layout.html.twig' %}

{% block toolbar %}
    {% set icon %}
        <span class="sf-toolbar-info-piece"><span class="sf-toolbar-status">{{ collector.requestCount }}</span> MCP</span>
    {% endset %}
    {{ parent() }}
{% endblock %}

{% block panel %}
    <h2>MCP Profiler Data</h2>

    <div class="sf-profiler-detail">
        <h3>Bundle Information</h3>
        <p><strong>Name:</strong> {{ collector.bundleName }}</p>
        <p><strong>Version:</strong> {{ collector.bundleVersion }}</p>
        <p><strong>Request Count:</strong> {{ collector.requestCount }}</p>
        <p><strong>Collected At:</strong> {{ collector.timestamp }}</p>

        {# Display custom data if available #}
        {# {% if collector.customData is not null %} #}
        {#     <h3>Custom Data</h3> #}
        {#     <pre>{{ collector.customData|json_encode(constant('JSON_PRETTY_PRINT')) }}</pre> #}
        {# {% endif %} #}
    </div>
{% endblock %}

```

--------------------------------

### MCPDataCollector Class Example

Source: https://github.com/killerwolf/mcp-profiler-bundle/blob/main/Resources/docs/data_collector.md

Illustrates how to extend the MCPDataCollector to include additional data. This involves adding properties in the collect() method and creating corresponding getter methods.

```php
<?php

namespace KillerWolf\Bundle\MCPProfilerBundle\DataCollector;

use Symfony\Component\HttpKernel\DataCollector\DataCollector;

class MCPDataCollector extends DataCollector
{
    private int $requestCount = 0;
    private string $bundleName;
    private string $bundleVersion;

    public function __construct(string $bundleName, string $bundleVersion)
    {
        $this->bundleName = $bundleName;
        $this->bundleVersion = $bundleVersion;
    }

    public function collect(Request $request, Response $response, Exception $exception = null): void
    {
        // Collect basic information
        $this->data = [
            'bundle_name' => $this->bundleName,
            'bundle_version' => $this->bundleVersion,
            'request_count' => ++$this->requestCount,
            'timestamp' => (new DateTime())->format('Y-m-d H:i:s'),
        ];

        // Add custom data here
        // $this->data['custom_data'] = $this->getCustomData();
    }

    public function getBundleName(): string
    {
        return $this->data['bundle_name'];
    }

    public function getBundleVersion(): string
    {
        return $this->data['bundle_version'];
    }

    public function getRequestCount(): int
    {
        return $this->data['request_count'];
    }

    public function getTimestamp(): string
    {
        return $this->data['timestamp'];
    }

    // Add getter for custom data if implemented
    // public function getCustomData(): mixed
    // {
    //     return $this->data['custom_data'] ?? null;
    // }

    public function getName(): string
    {
        return 'mcp_profiler.mcp_data_collector';
    }
}

```

--------------------------------

### Interact with Symfony Profiler via CLI

Source: https://github.com/killerwolf/mcp-profiler-bundle/blob/main/README.md

Demonstrates how to use the Symfony console command provided by the bundle to interact with the profiler. Includes listing recent entries and showing specific profile details.

```bash
# List recent profiler entries
bin/console mcp:profiler list --limit=20

# Show details for a specific profile
bin/console mcp:profiler show <token>
bin/console mcp:profiler show <token> --collector=request
```

--------------------------------

### Using the MCP Inspector CLI

Source: https://github.com/killerwolf/mcp-profiler-bundle/blob/main/README.md

Launches the MCP Inspector command-line interface using npx. This tool is used to interact with your MCP Server and test tools and resources.

```bash
npx --registry https://registry.npmjs.org @modelcontextprotocol/inspector
```

--------------------------------

### Configure MCP Server in IDE

Source: https://github.com/killerwolf/mcp-profiler-bundle/blob/main/README.md

Configuration for setting up the MCP server in your IDE (e.g., Cursor, Claude Code, Cline). This JSON defines the command to run the Symfony console application.

```json
{
  "mcpServers": {
    "symfony-mcp": {
      "command": "/path/to/your/symfony/project/bin/console",
      "args": [
        "mcp:server:run"
      ]
    }
  }
}
```

--------------------------------

### ProfilerList Tool Implementation

Source: https://github.com/killerwolf/mcp-profiler-bundle/blob/main/docs/mcp_server_multi_app_plan.md

Implements the `ProfilerList` tool's execute method to find all profiles across applications, sort them by time, limit the results, and return them as JSON. It utilizes the `findProfilerForToken` helper to locate profiles.

```php
<?php

namespace Killerwolf\MCPProfilerBundle\Tool;

use Symfony\Component\HttpKernel\Profiler\Profiler;
use Symfony\Component\HttpKernel\Profiler\FileProfilerStorage;
use Symfony\Component\Finder\Finder;
use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;

class ProfilerList extends AbstractProfilerTool
{
    private int $limit;

    public function __construct(ParameterBagInterface $parameterBag, string $baseCacheDir, string $environment, int $limit = 10)
    {
        parent::__construct($parameterBag, $baseCacheDir, $environment);
        $this->limit = $limit;
    }

    public function execute(string $token = null): string
    {
        $allProfiles = [];
        $finder = new Finder();
        $finder->directories()->in($this->baseCacheDir)->depth(0)->name('*_*');

        foreach ($finder as $appIdDir) {
            $profilerDir = $appIdDir->getRealPath() . '/' . $this->environment . '/profiler';
            if (is_dir($profilerDir)) {
                $storage = new FileProfilerStorage('file:' . $profilerDir);
                $tokens = $storage->find(""); // Find all tokens for this app
                foreach ($tokens as $tokenInfo) {
                    $profile = $storage->read($tokenInfo['token']);
                    if ($profile) {
                        $allProfiles[] = ['appId' => $appIdDir->getFilename(), 'profile' => $profile];
                    }
                }
            }
        }

        // Sort by time descending
        usort($allProfiles, function ($a, $b) {
            return $b['profile']->getTime() <=> $a['profile']->getTime();
        });

        // Limit results
        $limitedProfiles = array_slice($allProfiles, 0, $this->limit);

        // Format results
        $formattedResults = [];
        foreach ($limitedProfiles as $item) {
            $formattedResults[] = [
                'appId' => $item['appId'],
                'token' => $item['profile']->getToken(),
                'method' => $item['profile']->getMethod(),
                'url' => $item['profile']->getUrl(),
                'ip' => $item['profile']->getIp(),
                'time' => $item['profile']->getTime(),
                'statusCode' => $item['profile']->getStatusCode(),
            ];
        }

        return json_encode($formattedResults);
    }
}

```

--------------------------------

### Mermaid Diagram: Multi-App MCP Server Profiling

Source: https://github.com/killerwolf/mcp-profiler-bundle/blob/main/docs/mcp_server_multi_app_plan.md

Visual representation of the project's workflow for enabling multi-application support in the MCP profiler. It breaks down the process into three phases: modifying the command, updating tool classes, and updating service configuration.

```mermaid
graph TD
    Start[Start Task: Multi-App MCP Server] --> ModServerCmd[Phase 1: Modify RunMCPServerCommand.php];
    ModServerCmd --> ModServerConst[Update Constructor: Inject cacheDir, environment];
    ModServerCmd --> ModServerCallTool[Update callTool: Derive paths, Instantiate Tools w/ new params];

    ModServerCallTool --> ModToolClasses[Phase 2: Modify Tool Classes];

    subgraph Phase 2: Modify Tool Classes
        direction LR
        ModToolConst[Update Constructors: Accept baseCacheDir, environment] --> ModToolExec[Update execute Methods];
        ModToolExec --> ImplMultiApp[Implement Multi-App Discovery Finder, Loop];
        ImplMultiApp --> CreateTemp[Create Temp Storage & Profiler per App];
        CreateTemp --> AdaptLogic[Adapt Core Logic];

        subgraph Adapt Core Logic
            direction TB
            ListLogic[ProfilerList: Aggregate profiles + appId, Sort, Limit]
            GetLogic[ProfilerGet*ByToken: Search apps for token, Load profile]
        end
    end

    ModToolClasses --> UpdateDI[Phase 3: Update Service Configuration];
    UpdateDI --> InjectParams[Inject %kernel.cache_dir%, %kernel.environment% into RunMCPServerCommand];

    InjectParams --> End[Plan Complete];

    style Start fill:#lightgrey,stroke:#333,stroke-width:2px
    style End fill:#lightgrey,stroke:#333,stroke-width:2px
```

--------------------------------

### Refactor RunMCPServerCommand Constructor

Source: https://github.com/killerwolf/mcp-profiler-bundle/blob/main/docs/mcp_server_multi_app_plan.md

Modifies the constructor of `RunMCPServerCommand.php` to accept cache directory and environment as arguments, removing direct profiler injection. This change prepares the class for multi-application support by allowing it to dynamically determine cache paths.

```php
public function __construct(string $cacheDir, string $environment, ParameterBagInterface $parameterBag)
{
    // Remove the profiler property
    // Add private properties $cacheDir and $environment
    $this->cacheDir = $cacheDir;
    $this->environment = $environment;
    $this->parameterBag = $parameterBag;
}
```

--------------------------------

### Configure MCP Profiler Bundle

Source: https://github.com/killerwolf/mcp-profiler-bundle/blob/main/README.md

Adds the MCP Profiler Bundle to your Symfony application's configuration in `config/bundles.php`. This enables the bundle for development environments.

```php
return [
    // ...
    Killerwolf\MCPProfilerBundle\MCPProfilerBundle::class => ['dev' => true],
];
```

--------------------------------

### ProfilerGetByTokenTool Implementation

Source: https://github.com/killerwolf/mcp-profiler-bundle/blob/main/docs/mcp_server_multi_app_plan.md

Implements the `ProfilerGetByTokenTool`'s execute method to retrieve basic profile information and all collectors for a given token across applications. It includes the application ID in the returned data.

```php
<?php

namespace Killerwolf\MCPProfilerBundle\Tool;

use Symfony\Component\HttpKernel\Profiler\Profiler;
use Symfony\Component\HttpKernel\Profiler\FileProfilerStorage;
use Symfony\Component\Finder\Finder;
use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;

class ProfilerGetByTokenTool extends AbstractProfilerTool
{
    public function __construct(ParameterBagInterface $parameterBag, string $baseCacheDir, string $environment)
    {
        parent::__construct($parameterBag, $baseCacheDir, $environment);
    }

    public function execute(string $token): string
    {
        $profileData = $this->findProfileAndAppId($token);

        if (!$profileData) {
            return json_encode(['error' => 'Profile not found']);
        }

        $tempProfiler = $profileData['profiler'];
        $foundAppId = $profileData['appId'];

        $profile = $tempProfiler->loadProfile($token);
        if (!$profile) {
            return json_encode(['error' => 'Profile data corrupted']);
        }

        $collectors = [];
        foreach ($profile->getCollectors() as $collector) {
            $collectors[$collector->getName()] = [
                'data' => $collector->getData(),
                'collected' => $collector->collect()
            ];
        }

        return json_encode([
            'appId' => $foundAppId,
            'token' => $profile->getToken(),
            'method' => $profile->getMethod(),
            'url' => $profile->getUrl(),
            'ip' => $profile->getIp(),
            'time' => $profile->getTime(),
            'statusCode' => $profile->getStatusCode(),
            'collectors' => $collectors
        ]);
    }

    private function findProfileAndAppId(string $token)
    {
        $finder = new Finder();
        $finder->directories()->in($this->baseCacheDir)->depth(0)->name('*_*');

        foreach ($finder as $appIdDir) {
            $profilerDir = $appIdDir->getRealPath() . '/' . $this->environment . '/profiler';
            if (is_dir($profilerDir)) {
                $storage = new FileProfilerStorage('file:' . $profilerDir);
                if ($storage->read($token)) {
                    $tempProfiler = new Profiler($storage);
                    return ['profiler' => $tempProfiler, 'appId' => $appIdDir->getFilename()];
                }
            }
        }
        return null;
    }
}

```

--------------------------------

### Update RunMCPServerCommand callTool Method

Source: https://github.com/killerwolf/mcp-profiler-bundle/blob/main/docs/mcp_server_multi_app_plan.md

Updates the `callTool` method in `RunMCPServerCommand.php` to derive the base cache directory and environment name. It then instantiates profiler tool classes with these new parameters, enabling them to access application-specific cache data.

```php
$baseCacheDir = dirname(dirname($this->cacheDir)); // e.g., /path/to/project/var/cache
$envName = $this->environment; // Use the injected environment name

// Update tool instantiation:
'profiler:list' => (new ProfilerList($baseCacheDir, $envName, $this->parameterBag))->execute(...)
'profiler:get_collectors' => (new ProfilerGetAllCollectorByToken($baseCacheDir, $envName))->execute(...)
'profiler:get_collector' => (new ProfilerGetOneCollectorByToken($baseCacheDir, $envName))->execute(...)
'profiler:get_by_token' => (new ProfilerGetByTokenTool($baseCacheDir, $envName, $this->parameterBag))->execute(...)
```

--------------------------------

### Refactor Tool Classes for Multi-App Profiling

Source: https://github.com/killerwolf/mcp-profiler-bundle/blob/main/docs/mcp_server_multi_app_plan.md

Updates the constructor and execute methods of tool classes (`ProfilerList`, `ProfilerGetAllCollectorByToken`, `ProfilerGetOneCollectorByToken`, `ProfilerGetByTokenTool`) to handle application-specific profiler directories using Symfony Finder and FileProfilerStorage. This enables multi-application logic within each tool.

```php
<?php

namespace Killerwolf\MCPProfilerBundle\Tool;

use Symfony\Component\HttpKernel\Profiler\Profiler;
use Symfony\Component\HttpKernel\Profiler\FileProfilerStorage;
use Symfony\Component\Finder\Finder;
use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;

abstract class AbstractProfilerTool
{
    protected string $baseCacheDir;
    protected string $environment;

    public function __construct(ParameterBagInterface $parameterBag, string $baseCacheDir, string $environment)
    {
        // ParameterBagInterface is kept where applicable
        $this->baseCacheDir = $baseCacheDir;
        $this->environment = $environment;
    }

    protected function findProfilerForToken(string $token)
    {
        $finder = new Finder();
        $finder->directories()->in($this->baseCacheDir)->depth(0)->name('*_*');

        foreach ($finder as $appIdDir) {
            $profilerDir = $appIdDir->getRealPath() . '/' . $this->environment . '/profiler';
            if (is_dir($profilerDir)) {
                $storage = new FileProfilerStorage('file:' . $profilerDir);
                if ($storage->read($token)) {
                    $tempProfiler = new Profiler($storage);
                    return ['profiler' => $tempProfiler, 'appId' => $appIdDir->getFilename()];
                }
            }
        }

        return null;
    }

    // Other methods will be implemented in subclasses
}

```

--------------------------------

### ProfilerGetOneCollectorByToken Tool Implementation

Source: https://github.com/killerwolf/mcp-profiler-bundle/blob/main/docs/mcp_server_multi_app_plan.md

Implements the `ProfilerGetOneCollectorByToken` tool's execute method to find a specific profile by token across applications and retrieve a specific collector from it. It handles cases where the profile or collector is not found.

```php
<?php

namespace Killerwolf\MCPProfilerBundle\Tool;

use Symfony\Component\HttpKernel\Profiler\Profiler;
use Symfony\Component\HttpKernel\Profiler\FileProfilerStorage;
use Symfony\Component\Finder\Finder;
use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;

class ProfilerGetOneCollectorByToken extends AbstractProfilerTool
{
    public function __construct(ParameterBagInterface $parameterBag, string $baseCacheDir, string $environment)
    {
        parent::__construct($parameterBag, $baseCacheDir, $environment);
    }

    public function execute(string $token, string $collectorName): string
    {
        $profileData = $this->findProfileAndAppId($token);

        if (!$profileData) {
            return json_encode(['error' => 'Profile not found']);
        }

        $tempProfiler = $profileData['profiler'];
        $foundAppId = $profileData['appId'];

        $profile = $tempProfiler->loadProfile($token);
        if (!$profile) {
            return json_encode(['error' => 'Profile data corrupted']);
        }

        $collector = $profile->getCollector($collectorName);

        if (!$collector) {
            return json_encode(['error' => sprintf('Collector "%s" not found for token "%s"', $collectorName, $token)]);
        }

        return json_encode([
            'appId' => $foundAppId,
            'token' => $token,
            'collector' => $collector->collect(),
            'data' => $collector->getData()
        ]);
    }

    private function findProfileAndAppId(string $token)
    {
        $finder = new Finder();
        $finder->directories()->in($this->baseCacheDir)->depth(0)->name('*_*');

        foreach ($finder as $appIdDir) {
            $profilerDir = $appIdDir->getRealPath() . '/' . $this->environment . '/profiler';
            if (is_dir($profilerDir)) {
                $storage = new FileProfilerStorage('file:' . $profilerDir);
                if ($storage->read($token)) {
                    $tempProfiler = new Profiler($storage);
                    return ['profiler' => $tempProfiler, 'appId' => $appIdDir->getFilename()];
                }
            }
        }
        return null;
    }
}

```

--------------------------------

### ProfilerGetAllCollectorByToken Tool Implementation

Source: https://github.com/killerwolf/mcp-profiler-bundle/blob/main/docs/mcp_server_multi_app_plan.md

Implements the `ProfilerGetAllCollectorByToken` tool's execute method to retrieve all collectors for a given profile token across applications. It handles cases where the profile is not found.

```php
<?php

namespace Killerwolf\MCPProfilerBundle\Tool;

use Symfony\Component\HttpKernel\Profiler\Profiler;
use Symfony\Component\HttpKernel\Profiler\FileProfilerStorage;
use Symfony\Component\Finder\Finder;
use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;

class ProfilerGetAllCollectorByToken extends AbstractProfilerTool
{
    public function __construct(ParameterBagInterface $parameterBag, string $baseCacheDir, string $environment)
    {
        parent::__construct($parameterBag, $baseCacheDir, $environment);
    }

    public function execute(string $token): string
    {
        $profileData = $this->findProfileAndAppId($token);

        if (!$profileData) {
            return json_encode(['error' => 'Profile not found']);
        }

        $tempProfiler = $profileData['profiler'];
        $foundAppId = $profileData['appId'];

        $profile = $tempProfiler->loadProfile($token);
        if (!$profile) {
            return json_encode(['error' => 'Profile data corrupted']);
        }

        $collectors = [];
        foreach ($profile->getCollectors() as $collector) {
            $collectors[$collector->getName()] = [
                'data' => $collector->getData(),
                'collected' => $collector->collect()
            ];
        }

        return json_encode([
            'appId' => $foundAppId,
            'token' => $token,
            'collectors' => $collectors
        ]);
    }

    private function findProfileAndAppId(string $token)
    {
        $finder = new Finder();
        $finder->directories()->in($this->baseCacheDir)->depth(0)->name('*_*');

        foreach ($finder as $appIdDir) {
            $profilerDir = $appIdDir->getRealPath() . '/' . $this->environment . '/profiler';
            if (is_dir($profilerDir)) {
                $storage = new FileProfilerStorage('file:' . $profilerDir);
                if ($storage->read($token)) {
                    $tempProfiler = new Profiler($storage);
                    return ['profiler' => $tempProfiler, 'appId' => $appIdDir->getFilename()];
                }
            }
        }
        return null;
    }
}

```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.