README

AI-powered development assistant for the Larafony PHP 8.5 framework. Provides scaffolding tools, documentation resources, and learning prompts accessible via Model Context Protocol (MCP).

Quick Start - No Installation Required!

You don't need to clone any repository or install anything locally. Larafony provides a public MCP server that you can connect to directly from your AI assistant.

Connect to Public MCP Server

Add the Larafony MCP server URL to your AI assistant:

https://larafony.com/mcp

This gives you instant access to:

• Complete framework documentation (36 topics)
• Project structure information
• Learning prompts and debugging helpers

AI Assistant Configuration

Claude Desktop

Edit your configuration file:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json
• Linux: ~/.config/claude/claude_desktop_config.json

Option A: Remote Server (Recommended)

{
  "mcpServers": {
    "larafony": {
      "url": "https://larafony.com/mcp"
    }
  }
}

Option B: Local Development Server

{
  "mcpServers": {
    "larafony": {
      "command": "php",
      "args": ["/path/to/your/project/bin/larafony", "mcp:start"]
    }
  }
}

Claude Desktop MCP Documentation

Cursor IDE

Open MCP settings: Ctrl+Shift+P → "Cursor Settings" → MCP section.

Or edit ~/.cursor/mcp.json (global) or .cursor/mcp.json (project):

Option A: Remote Server (Recommended)

{
  "mcpServers": {
    "larafony": {
      "url": "https://larafony.com/mcp"
    }
  }
}

Option B: Local Development Server

{
  "mcpServers": {
    "larafony": {
      "command": "php",
      "args": ["/path/to/your/project/bin/larafony", "mcp:start"]
    }
  }
}

Cursor MCP Documentation

Claude Code CLI

Option A: Remote Server (Recommended)

claude mcp add larafony --url https://larafony.com/mcp --scope user

Option B: Local Development Server

claude mcp add larafony --scope user -- php /path/to/your/project/bin/larafony mcp:start

Useful commands:

claude mcp list              # List all configured servers
claude mcp remove larafony   # Remove server
claude mcp get larafony      # Test server connection

Scope options:

• --scope local - Current project only (default)
• --scope project - Shared via .mcp.json
• --scope user - All your projects

Claude Code MCP Documentation

OpenAI Codex

Edit ~/.codex/config.toml:

[mcp.larafony]
url = "https://larafony.com/mcp"

Or add via CLI:

codex mcp add larafony --url https://larafony.com/mcp

Codex MCP Documentation

ChatGPT

ChatGPT does not currently support MCP servers natively. Use Claude Desktop, Cursor, Claude Code, or Codex instead.

Local Installation (For Development)

If you want to run the MCP assistant locally with full scaffolding tools:

Requirements

• PHP 8.5+
• Larafony Core 2.0+
• Composer

Installation

composer require larafony/mcp-assistant

Register the service provider in bootstrap/app.php:

use Larafony\McpAssistant\McpAssistantServiceProvider;

$app->withServiceProviders([
    // ... other providers
    McpAssistantServiceProvider::class
]);

Configuration

Create or update config/mcp.php:

<?php

return [
    'name' => env('APP_NAME', 'Larafony') . ' Assistant',
    'version' => '1.0.0',
    'instructions' => 'Larafony PHP 8.5 framework assistant.',

    'discovery' => [
        'path' => base_path(),
        'dirs' => [
            'src',
            'vendor/larafony/mcp-assistant/src/Tools',
            'vendor/larafony/mcp-assistant/src/Resources',
            'vendor/larafony/mcp-assistant/src/Prompts',
        ],
    ],

    // Disable course hints in learning prompts (for course owners)
    'disable_course_hints' => env('MCP_DISABLE_COURSE_HINTS', false),
];

Available Tools (Local Installation Only)

Scaffolding tools require local installation and create files in your project.

Tool Examples

Create a resource controller:

"Create a PostController with all CRUD methods"

Tool: make_controller
Parameters: { "name": "PostController", "resource": true }
Result: Created src/Controllers/PostController.php with index, show, store, update, destroy methods

Create a model with migration:

"Create a Comment model with migration"

Tool: make_model
Parameters: { "name": "Comment", "migration": true }
Result: Created src/Models/Comment.php and database/migrations/..._create_comments_table.php

Available Resources

Resources are available both on the public server and local installations.

Project Structure

Framework Documentation

Getting Started

HTTP Layer

Views

Database

Architecture

Security

Utilities

Async

Communication

Debugging

Bridges (Third-party Integrations)

Available Prompts

Learning Prompts

Debugging Prompts

Prompt Examples

Learn about models:

"Teach me about Larafony ORM models"

Prompt: learn_larafony
Parameters: { "topic": "models" }
Result: Detailed explanation of property hooks, #[BelongsTo], #[HasMany], #[BelongsToMany], #[CastUsing]

Build a feature:

"Help me build user authentication"

Prompt: build_feature
Parameters: { "feature": "user authentication" }
Result: Step-by-step guidance covering models, controllers, routes, middleware, and views

Larafony Conventions

This assistant understands and follows Larafony conventions:

Routing

use Larafony\Framework\Routing\Advanced\Attributes\Route;

class UserController extends Controller
{
    #[Route('/users', 'GET')]
    public function index(): ResponseInterface { ... }

    #[Route('/users/<id:\d+>', 'GET')]
    public function show(int $id): ResponseInterface { ... }
}

Models

use Larafony\Framework\Database\ORM\Model;
use Larafony\Framework\Database\ORM\Attributes\BelongsTo;
use Larafony\Framework\Database\ORM\Attributes\HasMany;

class Post extends Model
{
    public ?string $title {
        get => $this->title ?? null;
        set {
            $this->title = $value;
            $this->markPropertyAsChanged('title');
        }
    }

    #[BelongsTo(related: User::class, foreign_key: 'user_id')]
    public ?User $author { get => $this->relations->getRelation('author'); }

    #[HasMany(related: Comment::class, foreign_key: 'post_id')]
    public array $comments { get => $this->relations->getRelation('comments'); }
}

Views

<x-Layout title="Posts">
    <h1>All Posts</h1>

    @foreach($posts as $post)
        <x-PostCard :post="$post" />
    @endforeach
</x-Layout>

Development

Adding New Tools

Create a class in src/Tools/:

<?php

namespace Larafony\McpAssistant\Tools;

use Mcp\Capability\Attribute\McpTool;
use Mcp\Capability\Attribute\Schema;
use Mcp\Schema\Content\TextContent;

class MyCustomTool
{
    #[McpTool(
        name: 'my_custom_tool',
        description: 'Description for AI',
    )]
    public function execute(
        #[Schema(description: 'Parameter description', type: 'string')]
        string $param,
    ): TextContent {
        return new TextContent('Result');
    }
}

Adding New Resources

Create a class in src/Resources/:

<?php

namespace Larafony\McpAssistant\Resources;

use Mcp\Capability\Attribute\McpResource;

class MyResource
{
    #[McpResource(
        uri: 'my://resource',
        name: 'my-resource',  // alphanumeric, underscores, hyphens only
        description: 'Description for AI',
        mimeType: 'text/plain',
    )]
    public function getData(): string  // Return string, SDK wraps it
    {
        return 'Resource content';
    }
}

Adding New Prompts

Create a class in src/Prompts/:

<?php

namespace Larafony\McpAssistant\Prompts;

use Mcp\Capability\Attribute\McpPrompt;
use Mcp\Capability\Attribute\Schema;
use Mcp\Schema\Content\PromptMessage;
use Mcp\Schema\Content\TextContent;
use Mcp\Schema\Enum\Role;

class MyPrompt
{
    /**
     * @return array<int, PromptMessage>
     */
    #[McpPrompt(
        name: 'my_prompt',
        description: 'Description for AI',
    )]
    public function generate(
        #[Schema(description: 'Input parameter', type: 'string')]
        string $input,
    ): array {
        return [
            new PromptMessage(
                role: Role::User,
                content: new TextContent("Prompt with {$input}"),
            ),
        ];
    }
}

Running Tests

cd bridges/larafony-mcp-assistant
composer test

Learn How It's Built - From Scratch

Interested in how Larafony is built step by step?

Check out my full PHP 8.5 course, where I explain everything from architecture to implementation - no magic, just clean code.

Get it now at masterphp.eu

License

MIT License. Larafony-mcp-assistant is open-sourced software licensed under the MIT license.

Links

• Larafony Framework
• MCP SDK
• Model Context Protocol
• masterphp.eu - Full tutorials and documentation