Forem: Egemen KIRKAPLAN

Z.AI LARAVEL 12 SDK

Egemen KIRKAPLAN — Sat, 07 Feb 2026 14:13:58 +0000

Building the Future: How Z.AI Laravel SDK Brings Advanced AI to PHP Development

Laravel developers rejoice! The wait is finally over. The landscape of AI integration has been transformed with the official release of the Z.AI Laravel SDK - a groundbreaking package that's reshaping how we build intelligent applications in the PHP ecosystem.

🎯 What Makes Z.AI Laravel SDK Game-Changing?

🤖 Advanced AI Model Integration

At its core, the Z.AI Laravel SDK provides seamless access to cutting-edge AI models including GLM-4.7, GLM-4.6, and GLM-4.5 series. What sets this apart is the sophisticated implementation of advanced features:

Thinking Mode for Complex Reasoning

$response = Zai::chat()
    ->model('glm-4.7')
    ->thinking(true)  // Enable transparent reasoning process
    ->send('Analyze this Laravel application architecture for scalability improvements');

Tools and Function Calling
The SDK supports advanced tool integration, allowing AI to interact with external systems and APIs naturally:

$response = Zai::chat()
    ->tools(['code_analyzer', 'database_optimizer', 'security_scanner'])
    ->send('Review my Laravel code and suggest optimizations');

Real-time Streaming Responses

Zai::chat()
    ->stream()  // Get responses as they're generated
    ->onChunk(fn($chunk) => $this->broadcastToClients($chunk))
    ->send('Generate a comprehensive API documentation');

🖼️ Image Generation Excellence

The image generation capabilities are nothing short of impressive:

$image = Zai::image()
    ->model('glm-image')           // Or cogview-4-250304 for ultra-high quality
    ->quality('high')             // Standard, high, or ultra quality
    ->size('1024x1024')          // Custom dimensions supported
    ->style('photorealistic')      // Artistic styles available
    ->generate('A modern Laravel application dashboard with clean UI and responsive design');

This opens up incredible possibilities for dynamic content creation, automated image processing, and enhanced user experiences.

📄 OCR and Document Processing

One of the standout features is the advanced OCR capabilities:

$document = Zai::ocr()
    ->file($uploadedPdf)
    ->extractTables(true)          // Extract structured data from tables
    ->parseFormulas(true)          // Handle spreadsheet content
    ->layoutAnalysis(true)          // Understand document structure
    ->process();

// Returns structured data with:
// - Extracted text
// - Table data
// - Formulas and calculations
// - Layout information

This is revolutionary for invoice processing, document analysis, and data extraction applications.

💻 Developer Experience That Delights

Type Safety at Its Finest

The SDK embraces modern PHP development practices with comprehensive type hints:

use ZaiLaravelSdk\DTOs\ChatRequest;
use ZaiLaravelSdk\DTOs\ChatResponse;

function processAIRequest(ChatRequest $request): ChatResponse
{
    $response = Zai::chat()
        ->model($request->model)
        ->temperature($request->temperature)
        ->maxTokens($request->maxTokens)
        ->send($request->message);

    return $response;  // Fully typed response object
}

Fluent Interface Design

The API is designed with developer joy in mind:

$response = Zai::chat()
    ->asUser('system_analyst')
    ->withContext(['laravel_version' => '12.x', 'php_version' => '8.3'])
    ->temperature(0.7)
    ->maxTokens(2000)
    ->tools(['code_reviewer'])
    ->thinking(true)
    ->stream()
    ->send('Perform a comprehensive code review of this Laravel application');

Smart Validation System

The SDK includes intelligent validation that prevents invalid requests before they hit the API:

try {
    $response = Zai::image()
        ->validateModelCapabilities()  // Auto-validates model support
        ->validateImageDimensions()    // Ensures valid dimensions
        ->validateQualityLevel()        // Checks quality parameter
        ->generate('Ultra-high resolution architectural visualization');
} catch (InvalidModelException $e) {
    // Handle specific validation errors
}

🛡️ Production-Ready Architecture

Enterprise Error Handling

use ZaiLaravelSdk\Exceptions\ZaiException;
use ZaiLaravelSdk\Retry\ExponentialBackoff;

try {
    $response = Zai::chat()->send('Complex AI request');
} catch (ZaiException $e) {
    // Detailed error information
    $error = [
        'code' => $e->getCode(),
        'message' => $e->getMessage(),
        'retry_count' => $e->getRetryCount(),
        'is_recoverable' => $e->isRecoverable(),
        'suggested_action' => $e->getSuggestedAction()
    ];

    // Built-in retry logic with exponential backoff
    $retryStrategy = new ExponentialBackoff(maxRetries: 3, baseDelay: 1000);
}

Laravel Integration Excellence

The SDK integrates seamlessly with Laravel's ecosystem:

// Queue integration for background processing
dispatch(function () {
    $result = Zai::chat()->send('Time-intensive AI analysis');
})->onQueue('ai-processing');

// Event handling
Event::listen(AIRequestProcessed::class, function ($event) {
    Log::info('AI request completed', ['duration' => $event->duration]);
});

// Middleware support
Route::middleware(['ai.rate.limited'])->group(function () {
    Route::post('/ai/chat', [AIController::class, 'chat']);
});

🌟 Real-World Applications

Smart Code Review Assistant

class CodeReviewService
{
    public function analyzeCode(string $code): array
    {
        $analysis = Zai::chat()
            ->asUser('senior_laravel_developer')
            ->tools(['code_analyzer', 'security_scanner'])
            ->thinking(true)
            ->send("Review this Laravel code and provide suggestions for optimization, security improvements, and best practices:\n\n{$code}");

        return [
            'optimizations' => $analysis->getOptimizations(),
            'security_issues' => $analysis->getSecurityIssues(),
            'best_practices' => $analysis->getBestPractices(),
            'refactored_code' => $analysis->getRefactoredCode()
        ];
    }
}

Dynamic Content Generation System

class ContentGenerationService
{
    public function generateBlogPost(string $topic, string $style): array
    {
        $outline = Zai::chat()
            ->asUser('content_strategist')
            ->send("Create a detailed blog post outline about: {$topic} in {$style} style");

        $title = $outline->getTitle();
        $sections = $outline->getSections();

        $featuredImage = Zai::image()
            ->style('professional')
            ->generate("Modern blog post featured image about: {$title}");

        return [
            'title' => $title,
            'outline' => $sections,
            'featured_image' => $featuredImage,
            'seo_metadata' => $this->generateSEOMetadata($title, $topic)
        ];
    }
}

🎉 Why This Changes Everything

Unified Laravel Experience

No more wrestling with Guzzle requests, manual JSON parsing, or complex API integrations. The Z.AI Laravel SDK brings the "Laravel Way" to AI development - elegant, intuitive, and battle-tested. It transforms complex AI interactions into simple, expressive code that feels natural to any Laravel developer.

Future-Proof Architecture

The SDK is designed with adaptability in mind. Supporting multiple AI providers and models means your applications won't become obsolete as the AI landscape evolves. This investment in the Z.AI SDK is an investment in your future-proof codebase.

Enterprise Security

Built from the ground up with security best practices, the SDK includes rate limiting, input sanitization, and comprehensive error handling that protects both your application and your users.

🚀 Getting Started

Ready to revolutionize your Laravel applications with advanced AI capabilities?

Installation

composer require 0xmergen/zai-laravel-sdk

Configuration

// config/zai.php
return [
    'api_key' => env('ZAI_API_KEY'),
    'default_model' => 'glm-4.7',
    'timeout' => 30,
    'retry_attempts' => 3,
    'cache_enabled' => true,
];

Quick Start

use ZaiLaravelSdk\Facades\Zai;

// Simple chat
$response = Zai::chat()->send('Hello, AI world!');

// Advanced with all features
$response = Zai::chat()
    ->model('glm-4.7')
    ->thinking(true)
    ->tools(['data_analyzer'])
    ->stream()
    ->send('Analyze this dataset and provide insights');

🔮 The Future is Here

The Z.AI Laravel SDK isn't just another package - it's a complete paradigm shift in how PHP developers approach AI integration. With its elegant design, powerful features, and Laravel-first philosophy, it's setting the standard for AI development in the PHP ecosystem.

Whether you're building chatbots, content generators, intelligent automation systems, or next-generation applications, the Z.AI Laravel SDK provides the foundation you need to succeed.

The future of intelligent Laravel applications has arrived. Are you ready to build it?

Get started today: composer require 0xmergen/zai-laravel-sdk

Join the community: GitHub Discussions

Explore the docs: Documentation

LMAD MCP FOR LARAVEL

Egemen KIRKAPLAN — Fri, 30 Jan 2026 14:59:43 +0000

LMAD MCP Laravel API Discovery Tools

Introduction

When working with AI coding assistants like Claude Code, Cursor, or GitHub Copilot with Laravel projects, there's often a gap in what the AI can understand. The assistants can see the routes, but they lack context about:

What validation rules apply to a POST request?
What fields does the API actually return?
Where is the controller method defined?
What authorization logic is in place?

This means constantly having to copy-paste code, explain FormRequest rules, and describe JsonResource structures to the AI assistant. It's tedious and slows down development significantly.

LMAD (Laravel MCP API Discovery) is a new package that bridges this gap. It's an MCP (Model Context Protocol) server that gives AI assistants deep understanding of Laravel APIs. Instead of just route listings, LMAD provides complete endpoint analysis including validation rules, response schemas, file locations, and more.

You can find the package on GitHub: https://github.com/0xmergen/lmad

What is MCP?

MCP (Model Context Protocol) is an open standard that allows AI assistants to connect to external data sources and tools. Instead of an AI being limited to its training data, MCP enables it to:

Query your application's codebase in real-time
Access tools that can analyze your code
Provide context-aware assistance based on your actual code

Think of MCP as a "bridge" between AI assistants and your Laravel application.

Installation

You'll need at least PHP 8.2 and Laravel 11.0 to use this package.

composer require 0xmergen/lmad

After installing, LMAD will automatically register its MCP server in your Laravel application.

Configuring Your AI Assistant

LMAD works with several AI assistants that support MCP. Here's how to set it up:

Claude Code

Create or edit your Claude Desktop config file:

macOS/Linux: ~/.claude.json

{
  "mcpServers": {
    "lmad": {
      "command": "php",
      "args": [
        "artisan",
        "mcp:start",
        "lmad"
      ],
      "env": {
        "APP_ENV": "local"
      }
    }
  }
}

Cline (VS Code)

Install the Cline extension from the VS Code Marketplace.

Open VS Code Settings, search for "Cline: MCP Servers", and add:

{
  "lmad": {
    "command": "php",
    "args": [
      "artisan",
      "mcp:start",
      "lmad"
    ],
    "env": {
      "APP_ENV": "local"
    }
  }
}

Cursor

Cursor has built-in MCP support. Add the server configuration in your Cursor settings:

{
  "mcpServers": {
    "lmad": {
      "command": "php",
      "args": [
        "artisan",
        "mcp:start",
        "lmad"
      ],
      "env": {
        "APP_ENV": "local"
      }
    }
  }
}

After configuring, restart your AI assistant. The LMAD tools will be available for use when working on your Laravel project.

What LMAD Provides

LMAD provides 5 MCP tools that AI assistants can use to understand your Laravel APIs:

list_api_routes - List all API routes with filtering
get_route_details - Get detailed route information
get_request_rules - Analyze FormRequest validation rules
get_response_schema - Understand what APIs return
analyze_endpoint - Complete endpoint analysis (all-in-one)

Listing API Routes

The list_api_routes tool allows listing all API routes with optional filters. For example, to find all CRM-related routes:

The tool returns comprehensive information including:

Route URI and HTTP method
Controller class and method
Route middleware
File paths for easy navigation

Unlike Laravel Boost's basic route listing, LMAD provides:

Wildcard pattern matching (api/crm/*)
Multiple filter options (method, domain, vendor exclusion)
Exact file locations

Analyzing Request Validation

One of LMAD's most powerful features is the get_request_rules tool, which analyzes FormRequest validation rules.

For a FormRequest like App\Http\Requests\Crm\Company\StoreRequest, the tool returns:

{
  "class": "App\\Http\\Requests\\Crm\\Company\\StoreRequest",
  "rules": {
    "name": ["required", "string", "max:255"],
    "tax_number": ["nullable", "string", "max:50"],
    "email": ["nullable", "email", "max:255"],
    "employee_count": ["nullable", "integer", "min:0"],
    "status": ["nullable", "in:active,inactive,prospect"]
  },
  "custom_messages": {},
  "custom_attributes": {},
  "authorization": {
    "type": "bool",
    "returns": true
  }
}

This means your AI assistant can:

Generate valid API request payloads
Understand validation error scenarios
Know what fields are required/optional
See authorization logic at a glance

Understanding Response Schemas

The get_response_schema tool analyzes what your API endpoints actually return.

For a controller method returning a JsonResource:

{
  "type": "json_resource",
  "resource_class": "App\\Http\\Resources\\Crm\\Company\\CompanyResource",
  "fields": [
    "id", "name", "tax_number", "email", "phone",
    "website", "address", "city", "country",
    "employee_count", "status", "customers_count",
    "contacts_count", "created_at", "updated_at"
  ],
  "file": "app/Http/Resources/Crm/Company/CompanyResource.php",
  "start_line": 13
}

Now your AI assistant knows:

The exact structure of API responses
Which fields are returned
Where to find the Resource class
Conditional fields like whenCounted()

Complete Endpoint Analysis

The analyze_endpoint tool combines everything into a single call. For POST api/crm/companies, it returns:

{
  "route": {
    "uri": "api/crm/companies",
    "method": "POST",
    "middleware": ["api"],
    "name": "companies.store"
  },
  "controller": {
    "class": "App\\Http\\Controllers\\Crm\\CompanyController",
    "method": "store",
    "file": "app/Http/Controllers/Crm/CompanyController.php",
    "start_line": 23
  },
  "request": {
    "class": "App\\Http\\Requests\\Crm\\Company\\StoreRequest",
    "rules": {
      "name": ["required", "string", "max:255"],
      "tax_number": ["nullable", "string", "max:50"]
    }
  },
  "response": {
    "type": "json_response",
    "status_code": 201
  }
}

With this information, AI assistants can:

Generate accurate API calls
Create valid test cases
Write proper documentation
Understand the complete request/response flow

LMAD vs Laravel Boost

Feature	LMAD	Laravel Boost
Route Listing	✅	✅
FormRequest Analysis	✅	❌
Response Schema	✅	❌
File Locations	✅	❌
Authorization Logic	✅	❌
Complete Analysis	✅	❌

Laravel Boost provides basic route information. LMAD goes much deeper.

How It Works

LMAD uses PHP Reflection to analyze your code without executing it:

Route Discovery - Parses Laravel's route collection via RouteFacade::getRoutes()
Controller Inspection - Uses reflection to extract method signatures
Request Analysis - Parses FormRequest rules (string and array formats)
Response Analysis - Identifies JsonResource, Model, and Response types
Aggregation - Combines everything into structured JSON

This means:

No code execution required
Safe to use in production
Works with any Laravel project structure
Laravel 12 compatible (no Kernel.php needed)

Real-World Use Cases

1. Auto-Generating API Documentation
Your AI assistant can generate accurate docs based on actual FormRequest and JsonResource classes.

2. Writing Integration Tests

$this->postJson('/api/crm/companies', [
    'name' => 'Acme Corp',
    'email' => 'info@acme.com',
    'employee_count' => 50
])->assertCreated();

3. API Client Generation
Generate TypeScript interfaces based on actual JsonResource fields:

interface Company {
  id: number;
  name: string;
  tax_number?: string;
  email?: string;
  employee_count?: number;
  status?: 'active' | 'inactive' | 'prospect';
  created_at: string;
  updated_at: string;
}

Conclusion

LMAD fills an important gap for Laravel developers working with AI coding assistants. By providing deep API analysis through MCP, it enables AI assistants to understand your Laravel APIs at a much deeper level than simple route listings.

Whether you're generating documentation, writing tests, or building API clients, LMAD can significantly speed up your development workflow.

You can check out the package on GitHub: https://github.com/0xmergen/lmad

Metadata

Tags: laravel, mcp, model context protocol, ai, api, discovery, laravel 12, claude code, cursor, copilot

Author: @0xmergen

Estimated Reading Time: 5-7 minutes

Category: Packages