Skip to content
Back to search

laravel-mcp-server

A Laravel package for implementing secure Model Context Protocol servers using Streamable HTTP and SSE transport, providing real-time communication and a scalable tool system for enterprise environments.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/opgginc--laravel-mcp-server/badge.svg)](/listings/opgginc--laravel-mcp-server)

HTML

<a href="/listings/opgginc--laravel-mcp-server"><img src="/api/listings/opgginc--laravel-mcp-server/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

1) Install

composer require opgginc/laravel-mcp-server

2) Register an endpoint (Laravel)

use Illuminate\Support\Facades\Route;
use OPGG\LaravelMcpServer\Enums\ProtocolVersion;
use OPGG\LaravelMcpServer\Services\ToolService\Examples\HelloWorldTool;
use OPGG\LaravelMcpServer\Services\ToolService\Examples\VersionCheckTool;

Route::mcp('/mcp')
    ->setServerInfo(
        name: 'OP.GG MCP Server',
        version: '2.0.0',
    )
    ->setConfig(
        compactEnumExampleCount: 3,
    )
    ->setProtocolVersion(ProtocolVersion::V2025_11_25)
    ->enabledApi()
    ->tools([
        HelloWorldTool::class,
        VersionCheckTool::class,
    ]);

If you need compatibility with clients that do not support `2025-11-25`, set:

->setProtocolVersion(ProtocolVersion::V2025_06_18)

3) Verify

php artisan route:list | grep mcp
php artisan mcp:test-tool --list --endpoint=/mcp

Quick JSON-RPC check:

curl -X POST http://localhost:8000/mcp \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

Dynamic Tool Filtering by Query String

If one endpoint needs to expose different tool sets based on the incoming URL, attach a dynamic tools resolver to the route. The resolver owns both the declared tool catalog for the endpoint and the per-request visible subset.

use OPGG\LaravelMcpServer\Data\ToolResolutionContext;
use OPGG\LaravelMcpServer\Routing\McpEndpointDefinition;
use OPGG\LaravelMcpServer\Services\ToolService\DynamicToolResolverInterface;

final class LolPhaseToolResolver implements DynamicToolResolverInterface
{
    public function declaredTools(McpEndpointDefinition $endpoint): array
    {
        return [
            \App\MCP\Tools\LolSearchChampionMetaTool::class,
            \App\MCP\Tools\LolGetChampionAnalysisTool::class,
            \App\MCP\Tools\LolGetLiveItemRecommendationsTool::class,
        ];
    }

    public function resolve(
        McpEndpointDefinition $endpoint,
        ToolResolutionContext $context,
    ): array {
        return match ($context->queryParameters['phase'] ?? null) {
            'lobby' => [
                \App\MCP\Tools\LolSearchChampionMetaTool::class,
                \App\MCP\Tools\LolGetChampionAnalysisTool::class,
            ],
            'inprogress' => [
                \App\MCP\Tools\LolGetLiveItemRecommendationsTool::class,
            ],
            default => $this->declaredTools($endpoint),
        };
    }

    public function consumedQueryParameters(): array
    {
        return ['phase'];
    }
}
Route::mcp('/mcp/voice/lol/live')
    ->setServerInfo(
        name: 'OP.GG MCP Server - Voice lol Live',
        version: '1.0.0',
    )
    ->dynamicTools(LolPhaseToolResolver::class);

Example requests:

/mcp/voice/lol/live?phase=lobby
/mcp/voice/lol/live?phase=inprogress

The same filtered tool set is applied consistently to: - `tools/list` - `tools/call` - `tools/execute` - `POST /tools/{tool_name}` when `->enabledApi()` is enabled

If the same endpoint also uses `POST /tools/{tool_name}`, you can optionally expose a public `consumedQueryParameters(): array` hook on the resolver for query keys that should be used only for filtering and not forwarded as tool arguments. This hook is a documented convention and is not part of `DynamicToolResolverInterface`; resolvers that omit it will forward those query keys as tool arguments.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 593 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <h1 align="center">Laravel MCP Server by OP.GG</h1>
  2. <p align="center">
  3. Build a route-first MCP server in Laravel and Lumen
  4. </p>
  5. <p align="center">
  6. <a href="https://github.com/opgginc/laravel-mcp-server/actions"><img src="https://github.com/opgginc/laravel-mcp-server/actions/workflows/tests.yml/badge.svg" alt="Build Status"></a>
  7. <a href="https://packagist.org/packages/opgginc/laravel-mcp-server"><img src="https://img.shields.io/packagist/dt/opgginc/laravel-mcp-server" alt="Total Downloads"></a>
  8. <a href="https://packagist.org/packages/opgginc/laravel-mcp-server"><img src="https://img.shields.io/packagist/v/opgginc/laravel-mcp-server" alt="Latest Stable Version"></a>
  9. <a href="https://packagist.org/packages/opgginc/laravel-mcp-server"><img src="https://img.shields.io/packagist/l/opgginc/laravel-mcp-server" alt="License"></a>
  10. </p>
  11. <p align="center">
  12. <a href="https://op.gg/open-source/laravel-mcp-server">Official Website</a>
  13. </p>
  14. <p align="center">
  15. <a href="README.md">English</a> |
  16. <a href="README.pt-BR.md">Português do Brasil</a> |
  17. <a href="README.ko.md">한국어</a> |
  18. <a href="README.ru.md">Русский</a> |
  19. <a href="README.zh-CN.md">简体中文</a> |
  20. <a href="README.zh-TW.md">繁體中文</a> |
  21. <a href="README.pl.md">Polski</a> |
  22. <a href="README.es.md">Español</a>
  23. </p>
  24. <p align="center">
  25. <img src="docs/watch.gif" alt="Laravel MCP Server Demo" height="200">
  26. </p>
  27. ## Breaking Changes 2.0.0
  28. - Endpoint setup moved from config-driven registration to route-driven registration.
  29. - Streamable HTTP is the only supported transport.
  30. - Server metadata mutators are consolidated into `setServerInfo(...)`.
  31. - Legacy tool transport methods were removed from runtime (`messageType()`, `ProcessMessageType::SSE`).
  32. Full migration guide: [docs/migrations/v2.0.0-migration.md](docs/migrations/v2.0.0-migration.md)
  33. ## Overview
  34. Laravel MCP Server provides route-based MCP endpoint registration for Laravel and Lumen.
  35. Key points:
  36. - Streamable HTTP transport
  37. - Route-first configuration (`Route::mcp(...)` / `McpRoute::register(...)`)
  38. - Tool, resource, resource template, and prompt registration per endpoint
  39. - Route cache compatible endpoint metadata
  40. ## Requirements
  41. - PHP >= 8.2
  42. - Laravel (Illuminate) >= 9.x
  43. - Lumen >= 9.x (optional)
  44. ## Quick Start
  45. ### 1) Install
  46. ```bash
  47. composer require opgginc/laravel-mcp-server
  48. ```
  49. ### 2) Register an endpoint (Laravel)
  50. ```php
  51. use Illuminate\Support\Facades\Route;
  52. use OPGG\LaravelMcpServer\Enums\ProtocolVersion;
  53. use OPGG\LaravelMcpServer\Services\ToolService\Examples\HelloWorldTool;
  54. use OPGG\LaravelMcpServer\Services\ToolService\Examples\VersionCheckTool;
  55. Route::mcp('/mcp')
  56. ->setServerInfo(
  57. name: 'OP.GG MCP Server',
  58. version: '2.0.0',
  59. )
  60. ->setConfig(
  61. compactEnumExampleCount: 3,
  62. )
  63. ->setProtocolVersion(ProtocolVersion::V2025_11_25)
  64. ->enabledApi()
  65. ->tools([
  66. HelloWorldTool::class,
  67. VersionCheckTool::class,
  68. ]);
  69. ```
  70. If you need compatibility with clients that do not support `2025-11-25`, set:
  71. ```php
  72. ->setProtocolVersion(ProtocolVersion::V2025_06_18)
  73. ```
  74. ### 3) Verify
  75. ```bash
  76. php artisan route:list | grep mcp
  77. php artisan mcp:test-tool --list --endpoint=/mcp
  78. ```
  79. Quick JSON-RPC check:
  80. ```bash
  81. curl -X POST http://localhost:8000/mcp \
  82. -H "Content-Type: application/json" \
  83. -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'
  84. ```
  85. ### Dynamic Tool Filtering by Query String
  86. If one endpoint needs to expose different tool sets based on the incoming URL, attach a dynamic tools resolver to the route.
  87. The resolver owns both the declared tool catalog for the endpoint and the per-request visible subset.
  88. ```php
  89. use OPGG\LaravelMcpServer\Data\ToolResolutionContext;
  90. use OPGG\LaravelMcpServer\Routing\McpEndpointDefinition;
  91. use OPGG\LaravelMcpServer\Services\ToolService\DynamicToolResolverInterface;
  92. final class LolPhaseToolResolver implements DynamicToolResolverInterface
  93. {
  94. public function declaredTools(McpEndpointDefinition $endpoint): array
  95. {
  96. return [
  97. \App\MCP\Tools\LolSearchChampionMetaTool::class,
  98. \App\MCP\Tools\LolGetChampionAnalysisTool::class,
  99. \App\MCP\Tools\LolGetLiveItemRecommendationsTool::class,
  100. ];
  101. }
  102. public function resolve(
  103. McpEndpointDefinition $endpoint,
  104. ToolResolutionContext $context,
  105. ): array {
  106. return match ($context->queryParameters['phase'] ?? null) {
  107. 'lobby' => [
  108. \App\MCP\Tools\LolSearchChampionMetaTool::class,
  109. \App\MCP\Tools\LolGetChampionAnalysisTool::class,
  110. ],
  111. 'inprogress' => [
  112. \App\MCP\Tools\LolGetLiveItemRecommendationsTool::class,
  113. ],
  114. default => $this->declaredTools($endpoint),
  115. };
  116. }
  117. public function consumedQueryParameters(): array
  118. {
  119. return ['phase'];
  120. }
  121. }
  122. ```
  123. ```php
  124. Route::mcp('/mcp/voice/lol/live')
  125. ->setServerInfo(
  126. name: 'OP.GG MCP Server - Voice lol Live',
  127. version: '1.0.0',
  128. )
  129. ->dynamicTools(LolPhaseToolResolver::class);
  130. ```
  131. Example requests:
  132. ```text
  133. /mcp/voice/lol/live?phase=lobby
  134. /mcp/voice/lol/live?phase=inprogress
  135. ```
  136. The same filtered tool set is applied consistently to:
  137. - `tools/list`
  138. - `tools/call`
  139. - `tools/execute`
  140. - `POST /tools/{tool_name}` when `->enabledApi()` is enabled
  141. If the same endpoint also uses `POST /tools/{tool_name}`, you can optionally expose a public
  142. `consumedQueryParameters(): array` hook on the resolver for query keys that should be used only
  143. for filtering and not forwarded as tool arguments. This hook is a documented convention and is
  144. not part of `DynamicToolResolverInterface`; resolvers that omit it will forward those query keys
  145. as tool arguments.
  146. ## Lumen Setup
  147. ```php
  148. // bootstrap/app.php
  149. $app->withFacades();
  150. $app->withEloquent();
  151. $app->register(OPGG\LaravelMcpServer\LaravelMcpServerServiceProvider::class);
  152. ```
  153. ```php
  154. use OPGG\LaravelMcpServer\Routing\McpRoute;
  155. use OPGG\LaravelMcpServer\Services\ToolService\Examples\HelloWorldTool;
  156. McpRoute::register('/mcp')
  157. ->setServerInfo(
  158. name: 'OP.GG MCP Server',
  159. version: '2.0.0',
  160. )
  161. ->tools([
  162. HelloWorldTool::class,
  163. ]);
  164. ```
  165. ## Minimal Security (Production)
  166. Use Laravel middleware on your MCP route group.
  167. ```php
  168. use Illuminate\Support\Facades\Route;
  169. Route::middleware([
  170. 'auth:sanctum',
  171. 'throttle:100,1',
  172. ])->group(function (): void {
  173. Route::mcp('/mcp')
  174. ->setServerInfo(
  175. name: 'Secure MCP',
  176. version: '2.0.0',
  177. )
  178. ->tools([
  179. \App\MCP\Tools\MyCustomTool::class,
  180. ]);
  181. });
  182. ```
  183. ## v2.0.0 Migration Notes (from v1.0.0)
  184. - MCP endpoint setup moved from config to route registration.
  185. - Streamable HTTP is the only transport.
  186. - Server metadata mutators are consolidated into `setServerInfo(...)`.
  187. - Tool migration command is available for legacy signatures:
  188. ```bash
  189. php artisan mcp:migrate-tools
  190. ```
  191. Full guide: [docs/migrations/v2.0.0-migration.md](docs/migrations/v2.0.0-migration.md)
  192. ## Advanced Features (Quick Links)
  193. - Create tools: `php artisan make:mcp-tool ToolName`
  194. - Create resources: `php artisan make:mcp-resource ResourceName`
  195. - Create resource templates: `php artisan make:mcp-resource-template TemplateName`
  196. - Create prompts: `php artisan make:mcp-prompt PromptName`
  197. - Create notifications: `php artisan make:mcp-notification HandlerName --method=notifications/method`
  198. - Generate from OpenAPI: `php artisan make:swagger-mcp-tool <spec-url-or-file>`
  199. - Export tools to OpenAPI: `php artisan mcp:export-openapi --output=storage/api-docs-mcp/api-docs.json`
  200. Code references:
  201. - Tool examples: `src/Services/ToolService/Examples/`
  202. - Resource examples: `src/Services/ResourceService/Examples/`
  203. - Prompt service: `src/Services/PromptService/`
  204. - Notification handlers: `src/Server/Notification/`
  205. - Route builder: `src/Routing/McpRouteBuilder.php`
  206. ## Swagger/OpenAPI -> MCP Tool
  207. Generate MCP tools from a Swagger/OpenAPI spec:
  208. ```bash
  209. # From URL
  210. php artisan make:swagger-mcp-tool https://api.example.com/openapi.json
  211. # From local file
  212. php artisan make:swagger-mcp-tool ./specs/openapi.json
  213. ```
  214. Useful options:
  215. ```bash
  216. php artisan make:swagger-mcp-tool ./specs/openapi.json \
  217. --group-by=tag \
  218. --prefix=Billing \
  219. --test-api
  220. ```
  221. - `--group-by`: `tag`, `path`, or `none`
  222. - `--prefix`: class-name prefix for generated tools/resources
  223. - `--test-api`: test endpoint connectivity before generation
  224. Generation behavior:
  225. - In interactive mode, you can choose Tool or Resource per endpoint.
  226. - In non-interactive mode, `GET` endpoints are generated as Resources and other methods as Tools.
  227. ### Enhanced Interactive Preview
  228. If you run the command without `--group-by`, the generator shows an interactive preview of folder structure and file counts before creation.
  229. ```bash
  230. php artisan make:swagger-mcp-tool ./specs/openapi.json
  231. ```
  232. Example preview output:
  233. ```text
  234. Choose how to organize your generated tools and resources:
  235. Tag-based grouping (organize by OpenAPI tags)
  236. Total: 25 endpoints -> 15 tools + 10 resources
  237. Examples: Tools/Pet, Tools/Store, Tools/User
  238. Path-based grouping (organize by API path)
  239. Total: 25 endpoints -> 15 tools + 10 resources
  240. Examples: Tools/Api, Tools/Users, Tools/Orders
  241. No grouping (everything in root folder)
  242. Total: 25 endpoints -> 15 tools + 10 resources
  243. Examples: Tools/, Resources/
  244. ```
  245. After generation, register generated tool classes on your MCP endpoint:
  246. ```php
  247. use Illuminate\Support\Facades\Route;
  248. Route::mcp('/mcp')
  249. ->setServerInfo(
  250. name: 'Generated MCP Server',
  251. version: '2.0.0',
  252. )
  253. ->tools([
  254. \App\MCP\Tools\Billing\CreateInvoiceTool::class,
  255. \App\MCP\Tools\Billing\UpdateInvoiceTool::class,
  256. ]);
  257. ```
  258. ## MCP Tools -> OpenAPI Export
  259. Export all registered `ToolInterface` classes (via `Route::mcp(...)->tools([...])` or `->dynamicTools(...)`) to an OpenAPI JSON document using each tool's `inputSchema()`.
  260. Only endpoints configured with `->enabledApi()` are included in this export and exposed through `POST /tools/{tool_name}`.
  261. Operations are grouped by endpoint `name` using OpenAPI `tags`.
  262. If multiple endpoints register the same tool name, the operation keeps first-registration behavior and merges all matching endpoint names into `tags`.
  263. If route registration is missing, the command auto-discovers tools under default paths: `app/MCP/Tools` and `app/Tools`.
  264. ```bash
  265. # Default output: storage/api-docs-mcp/api-docs.json
  266. php artisan mcp:export-openapi
  267. # Custom output + metadata
  268. php artisan mcp:export-openapi \
  269. --output=storage/app/mcp.openapi.json \
  270. --title="MCP Tools API" \
  271. --api-version=2.1.0
  272. # Limit to one endpoint (id or path)
  273. php artisan mcp:export-openapi --endpoint=/mcp
  274. # Discover tools from additional directory paths
  275. php artisan mcp:export-openapi --discover-path=app/MCP/Tools
  276. # Existing output is overwritten by default
  277. php artisan mcp:export-openapi
  278. ```
  279. Enable Tool API route generation:
  280. ```php
  281. use Illuminate\Support\Facades\Route;
  282. Route::mcp('/mcp')
  283. ->setServerInfo(name: 'OP.GG MCP Server', version: '2.0.0')
  284. ->enabledApi()
  285. ->tools([
  286. \App\MCP\Tools\GreetingTool::class,
  287. ]);
  288. ```
  289. Swagger UI testing tip:
  290. - Exported operations use `query parameters` only (no `requestBody`) for simpler manual testing.
  291. - Required fields from each tool `inputSchema().required` are reflected in Swagger parameter validation.
  292. - Enum fields are exported with `schema.enum` so Swagger renders dropdown selections.
  293. - Array fields are exported with `style=form` + `explode=true` (repeat key format, e.g. `desired_output_fields=items&desired_output_fields=runes`).
  294. - `/tools/{tool_name}` argument parsing prefers query parameters over body/form payloads to avoid Swagger conflicts.
  295. - Enum fields without explicit `default`/`example` are auto-filled from the first enum value (or first non-null enum value).
  296. - String fields with descriptions like `e.g., en_US, ko_KR, ja_JP` auto-infer first sample value as `default` and `example`.
  297. ## Example Tool Class
  298. ```php
  299. <?php
  300. namespace App\MCP\Tools;
  301. use App\Enums\Platform;
  302. use OPGG\LaravelMcpServer\JsonSchema\JsonSchema;
  303. use OPGG\LaravelMcpServer\Services\ToolService\ToolInterface;
  304. class GreetingTool implements ToolInterface
  305. {
  306. public function name(): string
  307. {
  308. return 'greeting-tool';
  309. }
  310. public function description(): string
  311. {
  312. return 'Return a greeting message.';
  313. }
  314. public function inputSchema(): array
  315. {
  316. return [
  317. 'name' => JsonSchema::string()
  318. ->description('Developer Name')
  319. ->required(),
  320. 'platform' => JsonSchema::string()
  321. ->enum(Platform::class)
  322. ->description('Client platform')
  323. ->compact(),
  324. ];
  325. }
  326. public function annotations(): array
  327. {
  328. return [
  329. 'readOnlyHint' => true,
  330. 'destructiveHint' => false,
  331. ];
  332. }
  333. public function execute(array $arguments): mixed
  334. {
  335. return [
  336. 'message' => 'Hello '.$arguments['name'],
  337. ];
  338. }
  339. }
  340. ```
  341. ## JsonSchema Builder (Laravel-Style)
  342. This package provides its own JsonSchema builder under the `OPGG\LaravelMcpServer` namespace.
  343. You can define tool schemas in a Laravel 12-style fluent format while keeping `inputSchema(): array`.
  344. ```php
  345. <?php
  346. namespace App\MCP\Tools;
  347. use App\Enums\Platform;
  348. use OPGG\LaravelMcpServer\JsonSchema\JsonSchema;
  349. use OPGG\LaravelMcpServer\Services\ToolService\ToolInterface;
  350. class WeatherTool implements ToolInterface
  351. {
  352. public function name(): string
  353. {
  354. return 'weather-tool';
  355. }
  356. public function description(): string
  357. {
  358. return 'Get weather by location.';
  359. }
  360. public function inputSchema(): array
  361. {
  362. return [
  363. 'location' => JsonSchema::string()
  364. ->description('Location to query')
  365. ->required(),
  366. 'platform' => JsonSchema::string()
  367. ->enum(Platform::class)
  368. ->description('Client platform'),
  369. 'days' => JsonSchema::integer()
  370. ->min(1)
  371. ->max(7)
  372. ->default(1),
  373. ];
  374. }
  375. public function annotations(): array
  376. {
  377. return [];
  378. }
  379. public function execute(array $arguments): mixed
  380. {
  381. return ['ok' => true];
  382. }
  383. }
  384. ```
  385. Notes:
  386. - Existing full JSON Schema arrays are still supported.
  387. - `enum()` accepts either an array or a `BackedEnum::class`.
  388. - `compact()` can be chained after `enum()` to remove `enum` from emitted schema and append a compact hint to `description` (`compact()`, `compact(null)`, `compact(3)`, or `compact('custom hint')`).
  389. - Default compact example count is `3`, and it can be overridden per endpoint via `Route::mcp(...)->setConfig(compactEnumExampleCount: N)`.
  390. - When exporting (`tools/list`, OpenAPI), property maps are automatically normalized to JSON Schema object format.
  391. ## Example Prompt Class
  392. ```php
  393. <?php
  394. namespace App\MCP\Prompts;
  395. use OPGG\LaravelMcpServer\Services\PromptService\Prompt;
  396. class WelcomePrompt extends Prompt
  397. {
  398. public string $name = 'welcome-user';
  399. public ?string $description = 'Generate a welcome message.';
  400. public array $arguments = [
  401. [
  402. 'name' => 'username',
  403. 'description' => 'User name',
  404. 'required' => true,
  405. ],
  406. ];
  407. public string $text = 'Welcome, {username}!';
  408. }
  409. ```
  410. ## Example Resource Class
  411. ```php
  412. <?php
  413. namespace App\MCP\Resources;
  414. use OPGG\LaravelMcpServer\Services\ResourceService\Resource;
  415. class BuildInfoResource extends Resource
  416. {
  417. public string $uri = 'app://build-info';
  418. public string $name = 'Build Info';
  419. public ?string $mimeType = 'application/json';
  420. public function read(): array
  421. {
  422. return [
  423. 'uri' => $this->uri,
  424. 'mimeType' => $this->mimeType,
  425. 'text' => json_encode([
  426. 'version' => '2.0.0',
  427. 'environment' => app()->environment(),
  428. ], JSON_THROW_ON_ERROR),
  429. ];
  430. }
  431. }
  432. ```
  433. ## Register Examples on a Route
  434. ```php
  435. use App\MCP\Prompts\WelcomePrompt;
  436. use App\MCP\Resources\BuildInfoResource;
  437. use App\MCP\Tools\GreetingTool;
  438. use Illuminate\Support\Facades\Route;
  439. Route::mcp('/mcp')
  440. ->setServerInfo(
  441. name: 'Example MCP Server',
  442. version: '2.0.0',
  443. )
  444. ->tools([GreetingTool::class])
  445. ->resources([BuildInfoResource::class])
  446. ->prompts([WelcomePrompt::class]);
  447. ```
  448. ## Testing and Quality Commands
  449. ```bash
  450. vendor/bin/pest
  451. vendor/bin/phpstan analyse
  452. vendor/bin/pint
  453. ```
  454. ## Translation
  455. ```bash
  456. pip install -r scripts/requirements.txt
  457. export ANTHROPIC_API_KEY='your-api-key'
  458. python scripts/translate_readme.py
  459. ```
  460. Translate selected languages:
  461. ```bash
  462. python scripts/translate_readme.py es ko
  463. ```
  464. ## License
  465. This project is distributed under the MIT license.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.