<?php
// ServeurMCPBibliotheque.php

class ServeurMCPBibliotheque
{
    private array $livres = [
        ['id' => 1, 'titre' => 'Clean Code', 'auteur' => 'Robert Martin'],
        ['id' => 2, 'titre' => 'Design Patterns', 'auteur' => 'Gang of Four']
    ];

    public function traiterRequete(array $requete): array
    {
        $methode = $requete['method'];

        return match($methode) {
            'initialize' => $this->initialiser($requete),
            'initialized' => [],
            'resources/list' => $this->listerRessources(),
            'resources/read' => $this->lireRessource($requete['params']),
            'tools/list' => $this->listerOutils(),
            'tools/call' => $this->executerOutil($requete['params']),
            default => $this->erreurMethodeInconnue($methode)
        };
    }

    private function initialiser(array $requete): array
    {
        return [
            'jsonrpc' => '2.0',
            'result' => [
                'protocolVersion' => '2025-06',
                'capabilities' => [
                    'resources' => [],
                    'tools' => []
                ],
                'serverInfo' => [
                    'name' => 'Library MCP',
                    'version' => '1.0.0'
                ]
            ],
            'id' => $requete['id']
        ];
    }

    private function listerRessources(): array
    {
        return [
            'jsonrpc' => '2.0',
            'result' => [
                'resources' => [
                    [
                        'uri' => 'library://books/catalog',
                        'name' => 'book_catalog.json',
                        'title' => 'Complete book catalog',
                        'description' => 'List of all available books',
                        'mimeType' => 'application/json'
                    ]
                ]
            ]
        ];
    }

    private function rechercherLivre(array $params): array
    {
        $terme = $params['arguments']['terme'] ?? '';

        $resultats = array_filter($this->livres, function($livre) use ($terme) {
            return stripos($livre['titre'], $terme) !== false ||
                   stripos($livre['auteur'], $terme) !== false;
        });

        return [
            'jsonrpc' => '2.0',
            'result' => [
                'content' => [
                    [
                        'type' => 'text',
                        'text' => count($resultats) > 0
                            ? 'Books found: ' . json_encode(array_values($resultats))
                            : 'No books found for: ' . $terme
                    ]
                ]
            ]
        ];
    }
}

<?php
// index.php

require_once 'ServeurMCPBibliotheque.php';

header('Content-Type: application/json');
header('Access-Control-Allow-Origin: *');
header('Access-Control-Allow-Methods: POST');
header('Access-Control-Allow-Headers: Content-Type');

if ($_SERVER['REQUEST_METHOD'] !== 'POST') {
    http_response_code(405);
    echo json_encode(['error' => 'Method not allowed']);
    exit;
}

$requete = json_decode(file_get_contents('php://input'), true);

if (!$requete) {
    http_response_code(400);
    echo json_encode(['error' => 'Invalid JSON']);
    exit;
}

$serveur = new ServeurMCPBibliotheque();
$reponse = $serveur->traiterRequete($requete);

echo json_encode($reponse);

class ServeurMCPSecurise
{
    private function validerEntree(array $params): bool
    {
        // Parameter validation
        if (!isset($params['arguments'])) {
            return false;
        }

        // String sanitization
        foreach ($params['arguments'] as $key => $value) {
            if (is_string($value)) {
                $params['arguments'][$key] = htmlspecialchars($value, ENT_QUOTES);
            }
        }

        return true;
    }

    private function formaterReponseSecurisee(string $contenu): array
    {
        // Removal of suspicious patterns
        $contenuNettoye = preg_replace('/\[INSTRUCTION[^\]]*\]/i', '', $contenu);

        return [
            'type' => 'text',
            'text' => $contenuNettoye
        ];
    }
}

// config/mcp.php
return [
    'tools' => [
        'search_user' => [
            'title' => 'User Search',
            'description' => 'Find a user by email',
            'handler' => UserSearchTool::class,
            'schema' => [
                'type' => 'object',
                'properties' => [
                    'email' => ['type' => 'string', 'format' => 'email']
                ]
            ]
        ]
    ]
];

// Tools available for AI
$tools = [
    'search_products' => [
        'description' => 'Search in catalog',
        'params' => ['term', 'category', 'max_price']
    ],
    'check_stock' => [
        'description' => 'Check availability',
        'params' => ['product_id', 'quantity']
    ],
    'calculate_shipping' => [
        'description' => 'Calculate shipping costs',
        'params' => ['postal_code', 'weight', 'carrier']
    ]
];

// MCP server for technical knowledge base
class SupportTechniqueMCP
{
    public function diagnostiquerProbleme(array $symptomes): array
    {
        // AI can now diagnose by accessing the solutions database
        $solutions = $this->rechercherSolutions($symptomes);
        $etapesDiagnostic = $this->genererDiagnostic($symptomes);

        return [
            'diagnostic' => $etapesDiagnostic,
            'possible_solutions' => $solutions,
            'escalation_needed' => $this->evaluerComplexite($symptomes)
        ];
    }
}

// Connection to financial APIs
class AnalyseFinanciereMCP
{
    public function analyserPortefeuille(string $userId): array
    {
        $positions = $this->getPositions($userId);
        $donneesMarche = $this->getDonneesTempsReel($positions);

        return [
            'global_performance' => $this->calculerPerformance($positions, $donneesMarche),
            'detected_risks' => $this->analyserRisques($positions),
            'recommendations' => $this->genererRecommandations($positions, $donneesMarche)
        ];
    }
}

class BestPracticesMCP
{
    public function listTools(): array
    {
        return [
            'tools' => [
                [
                    'name' => 'search_order',
                    'title' => 'Customer Order Search',
                    'description' => 'Find an order by number, customer email, or period. Supports advanced filters to refine search.',
                    'inputSchema' => [
                        'type' => 'object',
                        'properties' => [
                            'order_number' => [
                                'type' => 'string',
                                'description' => 'Exact order number (ex: CMD-2025-001234)',
                                'pattern' => '^CMD-[0-9]{4}-[0-9]{6}$'
                            ],
                            'customer_email' => [
                                'type' => 'string',
                                'format' => 'email',
                                'description' => 'Customer email to search all their orders'
                            ]
                        ]
                    ],
                    // CRUCIAL: Also define outputSchema
                    'outputSchema' => [
                        'type' => 'object',
                        'properties' => [
                            'orders_found' => [
                                'type' => 'array',
                                'items' => [
                                    'type' => 'object',
                                    'properties' => [
                                        'number' => ['type' => 'string'],
                                        'date' => ['type' => 'string', 'format' => 'date'],
                                        'amount' => ['type' => 'number'],
                                        'status' => ['type' => 'string']
                                    ]
                                ]
                            ]
                        ]
                    ]
                ]
            ]
        ];
    }
}

public function executeTool(array $params): array
{
    try {
        $toolName = $params['name'];
        $arguments = $params['arguments'] ?? [];

        // Argument validation
        if (!$this->validateArguments($toolName, $arguments)) {
            throw new InvalidArgumentException('Invalid arguments for ' . $toolName);
        }

        $result = $this->{'execute' . ucfirst($toolName)}($arguments);

        return [
            'jsonrpc' => '2.0',
            'result' => [
                'content' => [
                    [
                        'type' => 'text',
                        'text' => $result
                    ]
                ]
            ]
        ];

    } catch (Exception $e) {
        return [
            'jsonrpc' => '2.0',
            'error' => [
                'code' => -32603,
                'message' => 'Internal server error',
                'data' => [
                    'details' => $e->getMessage(),
                    'tool' => $toolName ?? 'unknown'
                ]
            ]
        ];
    }
}

class OptimizedMCPServer
{
    private Redis $cache;

    public function readResource(array $params): array
    {
        $uri = $params['uri'];
        $cacheKey = 'mcp:resource:' . md5($uri);

        // Cache check
        if ($cached = $this->cache->get($cacheKey)) {
            return json_decode($cached, true);
        }

        // Content generation
        $content = $this->generateResourceContent($uri);

        // Caching (5 minutes)
        $this->cache->setex($cacheKey, 300, json_encode($content));

        return $content;
    }
}