DEV Community: Snehal Rajeev Moon

What is a Large Language Model (LLM)

Snehal Rajeev Moon — Fri, 10 Oct 2025 16:51:14 +0000

Large Language Models (LLMs): What They Are and Why They Matter

If you’ve used ChatGPT, typed into Google Search, or even played with AI-powered image generators, you’ve already brushed shoulders with something called a Large Language Model (LLM). Sounds fancy, right? But at its core, an LLM is simply a type of artificial intelligence trained to understand and generate human-like text.

Think of it like this: an LLM is a supercharged autocomplete. Just like when your phone guesses the next word in your text message, an LLM predicts what comes next in a sentence. The big difference? Instead of being trained on a few messages, it’s been trained on massive amounts of text—from books, articles, websites, and more—so it can carry on conversations, answer questions, summarize documents, or even write poems and code.

How LLMs Work (Without the Tech Jargon)

Imagine you’ve read every book in your local library. Over time, you’d start noticing patterns—how stories are structured, what words often go together, how different writers explain ideas. That’s pretty much what an LLM does, but at an internet scale.

Instead of memorizing every single page, the model learns the patterns of language. That’s why it can generate a Shakespeare-style sonnet or explain quantum physics in plain English, depending on what you ask.

Real-World Examples You’ll Recognize

Customer support bots: Ever chatted with a help bot that actually gave you a useful answer instead of "please hold"? That’s often an LLM at work.

Email drafting: Tools like Gmail’s “Smart Compose” use LLM tech to guess what you’re about to type.

Education: Students use LLMs to get study help—like asking, “Explain photosynthesis to me like I’m 10.”

Coding: Developers use models like GitHub Copilot to write chunks of code faster, almost like pair-programming with a tireless teammate.

Creative writing: Writers use LLMs as brainstorming partners, bouncing off ideas for stories, blog posts, or even song lyrics.

The Human Side: Why People Care

What makes LLMs powerful isn’t just their ability to spit out words—it’s how they save time, spark creativity, and make complex things easier to grasp. Instead of spending an hour writing a report, you might draft one in ten minutes with AI help and then fine-tune it. Instead of struggling to learn a new concept, you can have it explained in simple terms, step by step.

Of course, they’re not perfect. Sometimes they “hallucinate” (make up facts) or produce answers that sound confident but are flat-out wrong. That’s why they’re best used as assistants, not replacements for human judgment.

Where It’s All Headed

LLMs are still evolving fast. We’re seeing models that don’t just handle text but also images, audio, and even video. The future isn’t just about chatting with AI—it’s about AI becoming a tool you can collaborate with in almost any task.
But here’s the key thing to remember: LLMs don’t “think” like us. They don’t have beliefs, opinions, or feelings. They’re pattern machines—powerful ones—that work best when guided by human goals and values.

Conclusion
Large Language Models aren’t science fiction anymore—they’re everyday tools. Whether you’re asking Siri to set a timer, having ChatGPT explain a tricky subject, or using AI to boost productivity at work, you’re seeing them in action.
The real trick isn’t just knowing that LLMs exist. It’s learning how to use them well: asking the right questions, checking their answers, and treating them like the powerful assistants they are.

Happy Reading!! ❤️ 🦄

MCP Servers Made Simple: Why Model Context Protocol Matters for AI

Snehal Rajeev Moon — Sat, 13 Sep 2025 17:58:30 +0000

What Is an MCP Server and Why Should You Care?

If you’ve been around development or systems engineering circles, you may have heard the term MCP server pop up. But what exactly is it, and why is it important? Let’s break it down without jargon.

What Is an MCP Server?

MCP stands for Model Context Protocol. An MCP server is essentially a backend service that exposes resources, data, or tools in a standardized way so that AI models (like ChatGPT) and client applications can use them consistently.

Think of it as a translator:

On one side, you have tools, APIs, and data sources.

On the other hand, you have AI models or client apps that need structured, safe access to those resources. The MCP server sits in the middle and makes sure the connection works smoothly.

Why Does MCP Matter?

AI systems are powerful, but they don’t natively know how to interact with every API, database, or tool you use. Without a common standard, each integration would be a one-off hack. That’s messy and not scalable.

MCP fixes this problem by providing:

Consistency – Clients and models know what to expect, no matter the server.
Security – Access to tools and data can be sandboxed and controlled.
Extensibility – You can add new servers for new tools without breaking old ones.
Future-proofing – As AI evolves, the protocol ensures integrations don’t constantly need rework.

How MCP Servers Work

At a high level, here’s the flow:

The MCP server registers its capabilities: what tools, data, or endpoints it provides.
A client (like a model-aware application) connects to it using the MCP standard.
The AI model requests operations—querying data, running a tool, retrieving results—through the MCP server.
Responses flow back in a predictable format.

This setup means developers can plug in different MCP servers—say one for a database, one for a file system, and one for a third-party API—and the client can use them all without special casing.

Use Cases for MCP Servers

Enterprise apps – Securely connect AI to internal databases or document stores.
DevOps – Give AI structured access to logs, configs, or cloud APIs.
Productivity tools – Let AI handle tasks like email, calendars, or file management.
Custom workflows – Build domain-specific tools (finance, healthcare, legal) that AI can call safely.

Getting Started With MCP Servers

If you’re a developer looking to experiment:

Check existing MCP server implementations – Many open-source projects are popping up.
Build your own server – If you’ve got an API or tool you want AI to use, wrapping it in an MCP server is straightforward.
Connect it to an MCP-compatible client – This could be your own app or a platform that supports MCP out of the box.

The protocol itself is still evolving, but it’s rapidly gaining traction because it solves a real pain point: making AI useful with your tools and data.

Final Thoughts

The real power of AI comes not just from reasoning but from action—actually using the tools and data you rely on. MCP servers are the backbone of that action layer, giving models a safe, standard way to plug into the world.

If you’re building AI-powered apps or workflows, MCP isn’t just a buzzword. It’s a practical standard that could become the glue between your tools and the next generation of intelligent systems.

What is n8n? A Complete Beginner’s Guide to Workflow Automation

Snehal Rajeev Moon — Thu, 28 Aug 2025 05:11:52 +0000

Hello Artisans,

In today's blog post, we will explore what n8n is and how we can automate our day-to-day tasks by automating these Workflows.
For example, we move data between apps, send repetitive emails, or double-check if we remembered to update a spreadsheet or not. It’s a boring, time-consuming task, and (let’s be honest) easy to mess up.

That’s exactly the kind of work n8n was built to eliminate.

What is n8n?

n8n (pronounced “n-eight-n”) is an open-source workflow automation tool. Think of it as a universal connector: it lets your apps, databases, and APIs talk to each other so you don’t have to.

Unlike other automation tools, n8n gives you:

Full Control → Self-host it or use n8n.cloud.
Flexibility → Build simple workflows or advanced ones with conditions, loops, and custom code.
Community Power → Tons of integrations, all improving thanks to open source contributors.
Scalability Without Big Bills → You’re not stuck paying per “zap” or “scenario.”

How It Works?

n8n uses a visual editor where you build workflows by dragging and connecting “nodes.”

Triggers: Events that start a workflow (like a new email or form submission).

Actions: The steps that happen next (send a Slack message, update Google Sheets, create a task in Notion, etc.).

It’s like playing with digital Lego blocks—easy to start, endlessly customizable.

Example: Your First Workflow

Let’s say you want to get notified in Slack whenever someone fills out a Typeform survey. Here’s how:

1. Add a Trigger Node → Select Typeform as your trigger. Now every time someone fills your form, n8n knows.

2. Add an Action Node → Select Slack. Connect your workspace and choose the channel.

3. Customize the Message → Pull in form responses dynamically (like name, email, or feedback).

4. Save & Activate → Boom—your Slack lights up instantly when a new response comes in.

No more refreshing Typeform. No more copy-pasting.

Other Cool Use Cases

Marketing Teams → Sync leads from landing pages straight into your CRM.

Developers → Auto-create GitHub issues when errors show up in logs.

Freelancers → Automate invoicing reminders or onboarding emails.

Everyday Life → Get a daily digest of your tasks, news, or even crypto prices.

If you find yourself repeating a process more than twice, chances are n8n can automate it.

Getting Started

Try the hosted version: n8n.cloud or self-host with Docker or npm (great for developers who want full control).
Explore templates from the n8n community for ready-made workflows.

Final Thoughts

Automation isn’t just about saving time—it’s about freeing your brain from the stuff that doesn’t spark joy. With n8n, you can finally stop being the “human API” between your tools and let them work together on autopilot.

So if you’ve been curious about automation but want something flexible, affordable, and open, you will probably fall in love with n8n.

Happy Reading!!
🦄❤️

Building a Cartoon Avatar Generator with Google AI Studio

Snehal Rajeev Moon — Mon, 04 Aug 2025 19:07:52 +0000

This post is my submission for DEV Education Track: Build Apps with Google AI Studio.

What I Built

I set out to build a single-page React web app that generates personalized cartoon avatars from simple text descriptions. The key prompt I used was: “Build a React app that converts user descriptions like ‘young woman with glasses and curly hair’ into cartoon-style avatars with bold outlines and clean lines.” I automatically enhanced prompts with styling instructions, such as “cartoon style, bold outlines, simple shapes, expressive facial features,” and added features for background color selection and accessory options. The app utilizes the Imagen API for image generation and features native Web Share functionality for seamless sharing.

Demo

Cartoon Avatar Generator right now, I don't have the budget to deploy/share production ready app.

Github Link

My Experience

This project is the perfect example of how AI can accelerate creative web development. I learned the importance of prompt engineering—specifically how adding detailed styling instructions improved image quality dramatically. The Imagen API delivered fast, professional-looking results that matched the prompt perfectly. Adding user customization for backgrounds and accessories made the app feel more personal and engaging. Implementing native Web Share was surprisingly straightforward and added great usability.

Overall, this experience showed me how modern AI tools and web APIs can turn ideas into polished apps quickly and efficiently.

Laravel 12 & Laravel Cloud: The Next Big Leap in Web Development

Snehal Rajeev Moon — Wed, 26 Feb 2025 06:05:37 +0000

Hello Artisans,

I hope you are doing great. Today's blog post is all about Laravel's echo system.

On February 24, 2025, the Laravel community celebrated a significant milestone with the release of Laravel 12. This version introduced several groundbreaking features designed to enhance developer productivity and application performance.

Native WebSocket Support with Laravel Echo
Enhanced Event Broadcasting
Streamlined Directory Structure
GraphQL API Integration
Performance and Security Enhancements

Along with this release of Laravel 12, the Laravel team unveiled several exciting developments to enhance the framework and its ecosystem.

New Laravel Website Launch

The official Laravel website received a comprehensive redesign. The revamped site offers a more intuitive navigation experience, improved accessibility, and a modern aesthetic that reflects Laravel's commitment to innovation and developer satisfaction. The new updated design ensures that both newcomers and seasoned developers can easily access documentation, tutorials, and community resources.

Enhanced Starter Kits

It also introduces new application starter kits for React, Vue, and Livewire. These kits utilize modern technologies such as Inertia 2, TypeScript, shadcn/ui, and Tailwind CSS, providing developers with a solid foundation for building dynamic applications.

The Livewire starter kit, in particular, leverages the Flux UI component library and Laravel Volt, streamlining the development of reactive, server-driven interfaces.

Additionally, each starter kit offers a variant powered by WorkOS AuthKit, enabling social authentication, passkeys, and SSO support. WorkOS provides free authentication for applications with up to 1 million monthly active users.

You can read more about it here.

Another, big release was Laravel Cloud.

Laravel Cloud is a fully managed infrastructure platform that will make it easy to deploy and scale Laravel applications, enabling developers to concentrate on feature development rather than server complexity.
Its arrival is a milestone addition to the Laravel ecosystem. It provides a smooth and streamlined solution for hosting and managing applications.

Key Features of Laravel Cloud

Easy Deployment: Deploy Laravel apps within less than a minute with no setup. By linking your Git provider and choosing the repository, Laravel Cloud takes care of deployment for you, bypassing manual configuration.
Automatic Scaling: Laravel Cloud provides integrated autoscaling to deal with changing traffic loads. The platform scales resources automatically, guaranteeing peak performance without manual configuration.
Managed Services: The service offers managed databases, caching, and object storage. This integration enables developers to integrate these services directly into their applications without maintenance and configuration overhead.
Improved Security: Laravel Cloud prioritizes security through automated provisioning of SSL certificates, firewall settings, and DDoS protection. These options secure applications against identified threats and vulnerabilities.
Collaborative Features: Created for individual developers and teams, Laravel Cloud provides team collaboration features. Users can invite team members, set permissions, and view application metrics in a group.

Pricing Plans

Flexible pricing available on Laravel Cloud for different project requirements:

Hobby Plan: Suitable for personal projects or small projects, the Hobby Plan delivers basic features at a low price.

Production Plan: Best for professional usage, it supports features like custom domains, large instance sizes, longer log retention, and supporting more users.

Business and Enterprise Plans: Optimized for mass usage, they provide unlimited auto-scaling, dedicated compute power, and so on, and provide solid performance for high-demand applications.

You can read more about Laravel Cloud from here.

Happy Reading!
Happy Coding!
🦄 ❤️

How to Use Maatwebsite Excel in Laravel for Importing & Exporting Data

Snehal Rajeev Moon — Sun, 23 Feb 2025 11:09:08 +0000

Hello Artisan,

This blog post will show how to implement import and export functionality in laravel applications using Maatwebsite Excel package.
So let's get started with an introduction.

Introduction

In Laravel, handling Excel files efficiently is crucial for data management tasks such as importing bulk records, generating reports, and exporting data. The Maatwebsite Excel package simplifies working with Excel files in Laravel applications. In this guide, we'll explore how to use this package to import and export data in Excel, with a small product-management application. Where we will have a list of products and each product belongs to a category.

First, we will set up our laravel project, and add products and categories, with the help of a seeder which gives us some test data.

Step 1: Install and setup laravel project

laravel new product-management

During installation, you will be prompted with questions to set up your application. You can choose the options that best suit your preferences.
I have selected no blade file, pest for testing, and MySQL database.

Step 2: Create model, migration, factory, and seeder for Category

php artisan make:model Category -msf

Step 3: Create a model, migration, factory, seeder, and Controller for the Product.

php artisan make:model Product -mcsf

Step 4: Next step is to define migration and the relationship between Category and Products.

Open a migration file for Category and add this code

Schema::create('categories', function (Blueprint $table) {
            $table->id();
            $table->string('name')->unique();
            $table->text('description')->nullable();
            $table->timestamps();
        });

Open a migration file for Product and add the below code

 Schema::create('products', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->text('description')->nullable();
            $table->decimal('price', 10, 2);
            $table->unsignedBigInteger('category_id');
            $table->foreign('category_id')->references('id')->on('categories')->onDelete('cascade');
            $table->timestamps();
        });

Now open a model files and add the following code:

Product.php


    /**
     * The attributes that are mass assignable.
     *
     * @var array
     */
    protected $fillable = ['name', 'description', 'price', 'category_id'];

    /**
     * Get list of categories.
     *
     * @return BelongsTo
     */
    public function category(): BelongsTo
    {
        return $this->belongsTo(Category::class);
    }

Category.php

    /**
     * The attributes that are mass assignable.
     *
     * @var array
     */
    protected $fillable = ['name', 'description'];

    /**
     * Get list of products.
     *
     * @return HasMany
     */
    public function products(): HasMany
    {
        return $this->hasMany(Product::class);
    }

Step 5: Now we will create and add test data with the help of the seeder.

CategoryFactory.php

   return [
            'name' => $this->faker->word,
            'description' => $this->faker->sentence,
        ];

ProductFactory.php

return [
            'name' => $this->faker->word,
            'description' => $this->faker->sentence,
            'price' => $this->faker->randomFloat(2, 5, 100),
            'category_id' => Category::factory(),
        ];

CategorySeeder.php

Category::factory(5)->create(); // Creates 5 random categories

ProductSeeder.php

Category::all()->each(function ($category) {
            Product::factory(5)->create(['category_id' => $category->id]); // Each category gets 5 products
        });

Now add these seeder files to DatabaseSeeder.php to generate test data in our database within the run method.

 $this->call([
            CategorySeeder::class,
            ProductSeeder::class,
        ]);

Step 6: Now run the migration command

php artisan migrate --seed

Our basic and required setup is done, now we will start with how to use Maatwebsite

Step 7: Install Maatwebsite Excel Package

To install the package, run the following command:

composer require maatwebsite/excel

After installation, the package automatically registers the service provider and facade. Now we need to publish its configuration file.

php artisan vendor:publish --provider="Maatwebsite\Excel\ExcelServiceProvider"

Step 8: Creating an Import Class

php artisan make:import ProductsImport --model=Product

This will create app/Imports/ProductsImport.php. Modify it as follows:

namespace App\Imports;

use App\Models\Product;
use Maatwebsite\Excel\Concerns\ToModel;
use Maatwebsite\Excel\Concerns\WithHeadingRow;

class ProductsImport implements ToModel, WithHeadingRow
{
    /**
     * @param array $row
     *
     * @return \Illuminate\Database\Eloquent\Product|null
     */
    public function model(array $row)
    {
        // Find category by id
        $category = \App\Models\Category::where('id', $row['category_id'])->first();

        if (!$category) {
            throw new \Exception('Invalid category: ' . $row['category_id']);
        }

        return new Product([
            'name'  => $row['name'],
            'description' => $row['description'],
            'price' => is_numeric($row['price']) ? floatval($row['price']) : 0,
            'category_id' => $category->id,
        ]);
    }
}

Step 9: Creating an Export Class

To export data as an Excel file, create an export class:

php artisan make:export ProductsExport --model=Product

Modify app/Exports/ProductsExport.php:

namespace App\Exports;

use App\Models\Product;
use Maatwebsite\Excel\Concerns\FromCollection;
use Maatwebsite\Excel\Concerns\WithHeadings;
use Maatwebsite\Excel\Concerns\WithEvents;

class ProductsExport implements FromCollection, WithHeadings, WithEvents
{
    /**
     * @return \Illuminate\Support\Collection
     */
    public function collection()
    {
        $products = collect();

        // Retrieve all products and include the related category name using eager loading
        // Chunk the results to avoid memory issues as the dataset grows
        Product::query()->with('category')->chunk(100, function ($chunk) use ($products) {
            $chunk->each(function ($product) use ($products) {
                $products->push([
                    'ID' => $product->id,
                    'Name' => $product->name,
                    'Description' => $product->description,
                    'Price' => $product->price,
                    'Category' => $product->category->name,
                    'Created At' => $product->created_at->format('Y-m-d H:i:s'),
                    'Updated At' => $product->updated_at->format('Y-m-d H:i:s'),
                ]);
            });
        });

        return $products;
    }

    /**
     * Add custom headers
     *
     * @return array
     */
    public function headings(): array
    {
        return [
            'ID',
            'Name',
            'Description',
            'Price',
            'Category',
            'Created At',
            'Updated At',
        ];
    }

    /**
     * Apply styles to the headings
     *
     * @return array
     */
    public function registerEvents(): array
    {
        return [
            \Maatwebsite\Excel\Events\AfterSheet::class => function (\Maatwebsite\Excel\Events\AfterSheet $event) {
                $headingCount = count($this->headings());
                $columnRange = 'A1:' . \PhpOffice\PhpSpreadsheet\Cell\Coordinate::stringFromColumnIndex($headingCount) . '1';
                $event->sheet->getDelegate()->getStyle($columnRange)->getFont()->setBold(true);
            },
        ];
    }
}

Step 10: Add export and import methods in a controller

class ProductController extends Controller
{
    public function index()
    {
        $products = Product::all();
        return view('products.index', compact('products'));
    }

    /**
     * Export products to excel file
     *
     * @return \Illuminate\Http\Response
     */
    public function export()
    {
        return Excel::download(new ProductsExport, 'products.xlsx');
    }

    /**
     * Import products from excel file
     *
     * @param Request $request
     * @return \Illuminate\Http\RedirectResponse
     */
    public function import(Request $request)
    {
        $request->validate(['file' => 'required|mimes:xlsx,csv']);

        Excel::import(new ProductsImport, $request->file('file'));

        return back()->with('success', 'Products Imported Successfully!');
    }
}

Step 11: Define Routes

In routes/web.php, add routes for importing and exporting:

Route::get('/products', [ProductController::class, 'index'])->name('products.index');
Route::post('/products/import-users', [ProductController::class, 'import'])->name('products.import');
Route::get('/products/export-products', [ProductController::class, 'export'])->name('products.export');

Step 12: Create a simple blade form
In your Blade file (resources/views/products/index.blade.php), add:

<!DOCTYPE html>
<html lang="en">

    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <meta http-equiv="X-UA-Compatible" content="ie=edge">
        <title>Product Import & Export</title>
        <script src="https://cdn.tailwindcss.com"></script>
    </head>

    <body class="bg-gray-100 flex items-center justify-center h-screen">

        <div class="bg-white p-8 rounded-lg shadow-md w-96">
            <h2 class="text-xl font-semibold text-gray-700 text-center mb-4">Import & Export Products</h2>

            <!-- Import Form -->
            <form action="{{ route('products.import') }}" method="POST" enctype="multipart/form-data" class="space-y-4">
                @csrf
                <label class="block">
                    <span class="text-gray-700">Upload File</span>
                    <input type="file" name="file" required
                        class="mt-2 block w-full px-3 py-2 border rounded-lg text-gray-700 bg-gray-50">
                </label>

                <button type="submit"
                    class="w-full bg-blue-600 text-white py-2 rounded-lg hover:bg-blue-700 transition">
                    Import Products
                </button>
            </form>

            <!-- Export Button -->
            <div class="mt-4 text-center">
                <a href="{{ route('products.export') }}" class="text-blue-600 hover:underline">Export Products</a>
            </div>
        </div>

    </body>

</html>

Conclusion

Using Maatwebsite Excel in Laravel simplifies Excel imports and exports. Whether you're handling large datasets or need quick CSV/Excel downloads, this package is an essential tool for Laravel developers. Try it out in your Laravel projects and streamline your data operations!

You can view the code on GitHub.

Happy Reading
Happy Coding
🦄 ❤️

A Guide to Git Conventional Commits

Snehal Rajeev Moon — Fri, 21 Feb 2025 17:22:04 +0000

Hello Artisans,

In today's blog, we will see how to use a conventional commit message and why is good practice to use it. Let's say you are working on a project with multiple developers, you know how messy commit messages can become. Incompatible commit messages make tracking changes difficult, understanding the project's history, and automating releases. This is where Git Conventional Commits come in.

Conventional Commits provide a structured format for writing commit messages. This process makes it easier to maintain a clean commit history, generate changelogs, and even automate versioning. In this blog, we'll explore the Conventional Commits specification, its benefits, and how you can integrate it into your workflow.

What Are Conventional Commits?

Conventional Commits are a lightweight convention for commit messages. They follow a structured pattern that provides meaningful information about the nature of a change. The basic syntax is:

type(scope): description

[optional body]

[optional footer(s)]

type: Defines the purpose of the commit (e.g., feat, fix, docs, style).
scope (optional): Specifies the part of the codebase the change affects.
description: A summary of the change.
body(optional): A more detailed explanation of the commit.
footer(s) (optional): Includes information such as breaking changes or issue references.

Common Commit Types

Here are the most commonly used commit types:

feat: Introduces a new feature.

Example: feat(auth): add login functionality

fix: Fixes a bug.

Example: fix(ui): resolve button alignment issue

docs: Updates documentation.

Example: docs(readme): update installation steps

style: Changes that do not affect functionality (e.g., formatting, linting).

Example: style(css): apply consistent spacing

refactor: Code refactoring without changing behavior.

Example: refactor(backend): improve API response handling

test: Adds or modifies tests.

Example: test(api): add unit tests for user routes

chore: Miscellaneous changes like dependency updates.

Example: chore(deps): update eslint to v8.5.0

Benefits of Using Conventional Commits

1. Improved Readability: Consistent commit messages make it easier to understand changes at a glance.

2. Better Collaboration: Teams can quickly identify changes relevant to their work.

3. Automated Changelogs: Tools like standard version and semantic release can generate changelogs automatically.

4. Versioning & Releases: Following Conventional Commits helps automate semantic versioning.

5. Enhanced Code Reviews: Clear commit messages to improve the code review process.

Conclusion
Use of Conventional Commits can significantly improve your development workflow by enforcing consistency, enhancing the documentation process, and enabling automation. Following a structured commit format makes it easier for humans and tools to understand and process your project's history.

Start using Conventional Commits today, and experience a cleaner, more efficient version control system! You can read more about it here.

Happy Coding!
Happy Reading!
❤️ 🦄

How to Create a Package in Laravel

Snehal Rajeev Moon — Sat, 15 Feb 2025 18:12:04 +0000

Hello Artisan,

Laravel is one of the most popular PHP frameworks, and its modular nature allows developers to create reusable packages. A package is a self-contained bundle of reusable code that can be shared and installed across multiple Laravel projects.

In this guide, we will walk you through creating a Laravel package from scratch for user-management.

Step 1: Set Up a New Laravel Package
Before starting, make sure you have Laravel installed. You can create a Laravel package in two ways:

Inside an existing Laravel application - (useful for testing while developing).
As a standalone package - (useful for distributing to others via Packagist).

1. Create a Directory for the Package
Navigate to your Laravel project’s packages directory (if it doesn’t exist, create it):

mkdir -p packages/laravelusermanager
cd packages/laravelusermanager

2. Initialize Composer
Run the following command inside the package directory to initialize Composer:

composer init

3. Define the Package in composer.json
In your package’s composer.json, ensure it includes the following:

{
    "name": "laraelusermanager",
    "description": "A sample Laravel package for user management",
    "type": "library",
    "autoload": {
        "psr-4": {
            "LaravelUserManager\\LaravelUserManager\\": "src/"
        }
    },
    "require": {
        "php": ">=8.0",
        "illuminate/support": "^10.0"
    }
}

4. Register the Package in Laravel
In your Laravel application, add your package’s namespace to composer.json in the root project:

"autoload": {
    "psr-4": {
        "LaravelUserManager\\LaravelUserManager\\": "packages/laravelusermanager/src/"
    }
}

Run composer dump-autoload to reload the autoload files.

Step 2: Create the Package Structure

Inside packages/laravelusermanager/, create the following directories:

mkdir -p src config routes resources/views

1. Create the Service Provider

Create a file src/PackageServiceProvider.php and define the service provider:

<?php

namespace VendorName\LaravelUserManager;

use Illuminate\Support\ServiceProvider;

class PackageServiceProvider extends ServiceProvider
{
    public function boot()
    {
        // Load routes
        $this->loadRoutesFrom(__DIR__.'/../routes/web.php');

        // Load views
        $this->loadViewsFrom(__DIR__.'/../resources/views', 'laravelusermanager');

        // Publish config
        $this->publishes([
            __DIR__.'/../config/config.php' => config_path('laravelusermanager.php'),
        ]);
    }

    public function register()
    {
        // Merge package config
        $this->mergeConfigFrom(__DIR__.'/../config/config.php', 'laravelusermanager');
    }
}

2. Define Routes

Create routes/web.php:

<?php

use Illuminate\Support\Facades\Route;
use LaravelUserManager\Controllers\UserController;

Route::resource('users', UserController::class);

3. Create a Configuration File

Create config/config.php:

<?php

return [
    'setting' => 'default_value',
];

4. Create a View

Create resources/views/users/index.blade.php:

<h1>User List</h1>
<table>
    <tr>
        <th>ID</th>
        <th>Name</th>
        <th>Email</th>
    </tr>
    @foreach ($users as $user)
        <tr>
            <td>{{ $user->id }}</td>
            <td>{{ $user->name }}</td>
            <td>{{ $user->email }}</td>
        </tr>
    @endforeach
</table>

5. Create a Controller

Create src/Controllers/UserController.php:

<?php

namespace LaravelUserManager\LaravelUserManager\Controllers;

use Illuminate\Http\Request;
use App\Models\User;
use Illuminate\Routing\Controller;

class UserController extends Controller
{
    public function index()
    {
        $users = User::all();
        return view('laravelusermanager::users.index', compact('users'));
    }

    public function create()
    {
        return view('laravelusermanager::users.create');
    }

    public function store(Request $request)
    {
        User::create($request->all());
        return redirect()->route('users.index');
    }
}

Step 3: Register the Package in Laravel

In config/app.php, add the service provider to the providers array:

'providers' => [
    LaravelUserManager\PackageServiceProvider::class,
];

Step 4: Test the Package

Run php artisan serve and visit http://localhost:8000/users. You should see the list of users.

Step 5: Publishing the Package

If you want to share your package with others: Push your code to GitHub.

Submit it to Packagist by registering it in your Composer account.

To install it in other Laravel projects, use:
composer require laravelusermanager

Conclusion
Creating a Laravel package is a great way to modularize and reuse code. By following these steps, you can build and distribute your own Laravel packages efficiently!

Happy Reading!
Happy Coding!
❤️ 🦄

Build a Bug-Free Applications using Laravel Unit Testing

Snehal Rajeev Moon — Mon, 30 Dec 2024 18:26:04 +0000

Hello Artisan,

Testing is a part of software development. It ensures your application is working as expected. Laravel has good support for testing, and it was designed with testing in mind. It provides Pest and PHPUnit for testing.

Once you install any laravel application you can see phpunit.xml already available in your application. By default application contains two separate directories in test directory one is for Feature and another is Unit. Unit is a smaller and isolated part of your application while Feature is used to test a larger part of your applications.

In this blog post, we will explore how to write tests using PHPUnit and how to integrate with your laravel application.

Why Unit Testing Matters?

Before getting into the details, let's quickly get a sense of why unit testing is important:

Code Quality: Tests catch bugs early in the game, thereby not risking them entering production.
Refactoring Confidence: Tests allow you to refactor with confidence because you don't fear breaking functionality.
Documentation: Tests act as living documentation for the behavior of your code.
Collaboration: They serve as a safety net for teams: they do not allow new changes to disrupt existing functionality.

Before we start writing the test cases, ensure you have installed the Laravel application.

Development environment is set up: Create a .env.testing file in the root directory of your project. This file is used instead of the .env file when you are running PHPUnit tests or executing Artisan commands with the --env=testing option.

Verify PHPUnit Configuration: Check the phpunit.xml file in your project root. This file configures _PHPUnit_ for your Laravel application.

Run the Default Tests: Laravel includes some example tests. You can run them using:

  php artisan test

This command executes all tests in the tests directory.

So let's start writing Your First Unit Test

Feature: For testing larger chunks of your application, often involving HTTP requests.

Unit: For testing individual classes and methods.

Let’s write a simple unit test:

1. Create a Test File

Use Artisan to generate a test file:

php artisan make:test SumOfTwoNumberTest --unit

This will create tests/Unit/SumOfTwoNumberTest.php.

2. Write a Test Case

Open the newly created test file and add your test logic:

<?php

namespace Tests\Unit;

use PHPUnit\Framework\TestCase;

class SumOfTwoNumberTest extends TestCase
{
    /**
     * A basic unit test example.
     *
     * @return void
     */
    public function test_addition()
    {
        $sum = 2 + 2;
        $this->assertEquals(4, $sum);
    }
}

3. Run the Test

Run your test using:

./vendor/bin/phpunit

You can also use the test Artisan command to run your tests. This command provides verbose test reports to ease the development and debugging process.

php artisan test

You should see an output indicating whether the test passed or failed.

Testing a Laravel Model

Let’s create a unit test for a Laravel model method. Assume we have a User model with a method getFullName:

1. Model Method

Add the method to your User model:

public function getFullName(): string
{
    return $this->first_name .' '. $this->last_name;
}

2. Create the Test

Generate a test file:

php artisan make:test UserTest --unit

Edit the test file to test the getFullName method:

<?php

namespace Tests\Unit;

use App\Models\User;
use PHPUnit\Framework\TestCase;

class UserTest extends TestCase
{
    public function test_get_full_name()
    {
        $user = new User();
        $user->first_name = 'John';
        $user->last_name = 'Doe';

        $this->assertEquals('John Doe', $user->getFullName());
    }
}

3. Execute the Test

Run the test:

php artisan test

You should see a success message if the method works as expected.

Writing a Feature Test

Feature tests in Laravel allow you to test larger parts of your application, such as routes, controllers, and middleware.

Let’s write an example feature test for a login page.

1. Generate a Feature Test

Use Artisan to create a new feature test:

php artisan make:test LoginTest

This will create tests/Feature/LoginTest.php.

2. Write the Test Logic

Open LoginTest.php file and add the below code:

<?php

namespace Tests\Feature;

use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;

class LoginTest extends TestCase
{
    use RefreshDatabase;

    /**
     * Test login page loads successfully.
     *
     * @return void
     */
    public function test_login_page_is_accessible()
    {
        $response = $this->get('/login');

        $response->assertStatus(200);
        $response->assertSee('Login');
    }

    /**
     * Test users can login with valid credentials.
     *
     * @return void
     */
    public function test_user_can_login_with_valid_credentials()
    {
        $user = User::factory()->create([
            'password' => bcrypt('password123'),
        ]);

        $response = $this->post('/login', [
            'email' => $user->email,
            'password' => 'password123',
        ]);

        $response->assertRedirect('/home');
        $this->assertAuthenticatedAs($user);
    }
}

3. Run the Feature Test

php artisan test

The output will show whether the login page is accessible and if the user can log in successfully.

Some best practices for writing Unit Test in Laravel

Descriptive Test Names: The names of the tests should be very descriptive of what is being tested.
Test One Thing at a Time: Every test should test only one functionality or behavior.
Use Factories and Seeders: Make use of Laravel's model factories and seeders to create test data.
Isolate Tests: Unit tests should not depend on external services such as a database or an API. Use mocks and stubs when necessary.

You can check Laravel documentation for more details.

Conclusion:
Unit and feature testing in Laravel are powerful ways to maintain code quality and ensure robust application behaviour. With the help of Laravel's PHPUnit writing and running tests is straightforward and efficient. Integrating tests into your development process will create more reliable, maintainable applications.

Happy Reading!!
Happy Coding!!
❤️ 🦄

Step-by-Step Guide: Running LLM Models with Ollama

Snehal Rajeev Moon — Sat, 21 Dec 2024 17:54:22 +0000

Hello Artisan,

In today's blog post, we will learn about Ollama, its key features, and how to install it on different OS.

What is Ollama?

Ollama is an open-source tool that allows you to run a Large Language Model (LLM) on your local machine. It has vast collections of LLM models. It ensures privacy and security of data making it a more popular choice among AI developers, researchers, and business owners who prioritize data confidentiality.
Ollama provides full ownership of your data and avoids potential risk.
Ollama is an offline tool that reduces latency and dependency on external servers, making it faster and more reliable.

Features of Ollama:

1. Management of AI model: It allows you to easily manage all its models on your system by giving you full control over it to download, run, and remove models from your systems. It also maintains the version of each model installed on your machine.

2. Command Line Interface (CLI): We operate on CLI to pull, run, and manage the LLM models locally. For users who prefer a more visual experience, it also supports third-party graphical user interface (GUI) tools like Open WebUI.

3. Multi-platform support: Ollama offers cross-platform compatibility that includes Windows, Linux, and MacOS, making it easy to integrate into your existing workflows, no matter which operating system you use.

How to use Ollama on multiple platforms

In this section, we will see how to download, install, and run Ollama locally on cross-platforms.

To download Ollma visit its official website here and download it as per your preferred operating system.
The installation process for MacOS is similar to Windows and for Linux, you have to run a command to install Ollama on your system.

I will walk you through the installation process for Windows, which you can follow similarly for macOS.

Click the download button for your preferred OS to download an executable file. Then, open the file to start the installation process.

To install it on Linux, open a terminal and run the following command to install Ollama on your machine.

curl -fsSL https://ollama.com/install.sh | sh

Yeah!, you have successfully installed Ollama. It will be in a tray of your system showing it was running.

Now we will see how to use, and download different models provided by Ollama with the help of the Command Line Interface (CLI).
Open your terminal and follow these steps. Here is a list of LLM models provided by Ollama.

ollama: this command will list all the available commands.
ollama -v or --version: display the version
ollama list: list all the models installed in your systems

Now we will see how to install the model using Ollama

The LLM model can be installed in two ways:

ollama pull model_name
ollama run model_name - If the model is not already downloaded on the system, it will first pull the model and then run it

We will install gemma2 model in our system
gemma2: Google Gemma 2 is a high-performing and efficient model available in three sizes: 2B, 9B, and 27B.

ollama run gemma2

It will open a prompt to write a message like below:

>>>Send a message (/? for help)

We have to write our prompt here, which returns the response.
To exit from the model we have to write /bye

You can now use any model provided by Ollama in these. Explore the model and try to use it as per your need.

Conclusion:
We have explored Ollama, an open-source tool that allows you to run LLM models locally, unlike other tools that rely on cloud servers. Ollama ensures data security and privacy, and we've learned how to run and use it on your local machine. It offers a simple and straightforward way to run LLM models effortlessly, directly on your system.

Happy Reading!
Happy Coding!
🦄 ❤️

Using Docker with Laravel Sail

Snehal Rajeev Moon — Thu, 05 Dec 2024 16:47:38 +0000

Hello Artisans,

Laravel Sail is a lightweight command-line interface (CLI) used for interacting with Laravel's default Docker environment. It provides developers an easy way to get started with Laravel in a fully containerized development environment without the hassle of manually setting up services like MySQL, Redis, or a queue worker in docker container.

In this guide, I'll walk you through the process of setting up and using Laravel Sail, highlighting its key features and benefits.

What is Laravel Sail?
Laravel Sail is a Docker development environment for Laravel. It includes everything you need to start building Laravel applications, such as PHP, MySQL, Redis, and more. Sail is particularly useful because it abstracts Docker complexities, allowing developers to focus on building applications.

Prerequisites
Before we start how to use Laravel Sail, make sure you have these setup in your machine:

1. Docker installed: Download and install Docker from its official website.
2. Composer: Laravel Sail requires Composer to install dependencies. You can download Composer from getcomposer.org.

I hope you have installed all the requirements.

Guide to Using Laravel Sail

Step 1: Install a New Laravel Project
Run the following command to create a new Laravel application and include Sail in your project dependencies:

composer create-project laravel/laravel laravel-sail-app
cd laravel-sail-app

Step 2: The next step is to install Laravel Sail in your project.

composer require laravel/sail --dev

After the installation is finished, we need to publish its Docker configuration files. You can do it by running the following command.

php artisan sail:install

Note: When a prompt appears you need to select your required services such as MySQL, Redis, or PostgreSQL.

Step 3: Start the Sail Environment
To start the development environment, use the following command:

./vendor/bin/sail up

The sail up command will start all the necessary containers for your Laravel application. By default, Sail runs containers for PHP, MySQL, and Nginx.

Step 4: Access Your Laravel Application
Once the Sail environment runs, you can access your application by navigating to http://localhost in your browser.

Step 5: Run Artisan Commands with Sail
Laravel Sail allows you to run Artisan commands seamlessly in the Docker environment. For example:

./vendor/bin/sail artisan migrate

You can also simplify your workflow by aliasing Sail:

alias sail='[ -f sail ] && bash sail || bash vendor/bin/sail'

Now you can run commands like:

sail up
sail artisan migrate

Step 6: Manage Containers
You can stop the containers with:

sail down

This command shuts down the Docker containers, preserving data in volumes like your database.

Step 7: Customizing the Docker Configuration
The docker-compose.yml file generated by Laravel Sail is highly customizable. You can add or remove services, change environment variables, or tweak resource allocations.

Now you are ready with a Docker container to interact with your laravel application.

Benefits of Using Laravel Sail

1. Easy to Use: Sail simplifies the Docker experience with straightforward commands.
2. Preconfigured Environment: Sail provides a preconfigured setup, saving you time during development.
3. Cross-Platform Support: Works seamlessly on Linux, macOS, and Windows (via WSL 2).
4. Supports Multiple Services: Easily integrate databases, caching layers, and queue workers.

Commonly used Sail Commands:

sail up: Start the Docker containers
sail down: Stop the Docker containers
sail artisan: Run Artisan commands
sail npm install: Install npm dependencies
sail test: Run Laravel test suite
sail mysql: Access MySQL command-line interface

Conclusion:
It's the best for developers who want to have a hassle-free development environment. Using the Docker-based approach, you can ensure consistency across all development machines, thus making collaboration easier. You will be able to set up and start using Laravel Sail to boost your productivity and focus on building great applications through this guide.

Happy Reading! 🦄 ❤️
Happy coding! 🦄 ❤️

Hacktoberfest 2024: Contributing to Open Source and Growing as a Developer

Snehal Rajeev Moon — Sun, 20 Oct 2024 14:08:37 +0000

October is here and so is Hacktoberfest. It is one great reason to look forward to October every year for open-source enthusiasts, developers, and tech communities.

It's been my second year and I am participating in different events organized by them. It is a month-long celebration of all things open source, where contributors are invited to improve, collaborate, and support open-source projects through learning, hands-on experiences, and rewarding participation.

What is Hacktoberfest?
Hacktoberfest began in 2014 and has become an annual event encouraging the tech community, which mainly comprises developers, to contribute to open-source projects. Organized by DigitalOcean in partnership with Cloudflare and Quira, this event allows developers to learn how to code, socialize with like-minded people, and give back to projects that make the modern internet go.

In 2014, there were just 676 participants however in 2023 it has nearly 98,000 contributors! Hacktoberfest is just growing and has become a huge global celebration, which unifies all coders and open-source advocates from every corner of the world.

How to Participate
It is pretty easy to participate in Hacktoberfest. Whether you're a huge developer or just getting started, this is a great opportunity to give back to open-source development. Here's an extremely fast guide on how you can join in:

Here is the link where you can sign up and start digging into the events that are suitable for you.

Rule: You need to contribute at least four pull or merge requests to an open-source repository between October 1 and October 31. For those who want to sponsor or contribute to a project, make sure the issue includes "Hacktoberfest-accepted" so that there is no confusion.

Be part of the Community on Discord: Share your journey and catch up with other contributors in Discord. Ask for their guidance and so on; let everyone know you're making progress.

Hacktoberfest is not just code; it's about the whole open-source ecosystem. Most sites are open source projects, so contributing to them means maintaining these critical technologies.

It also allows you to take part by volunteering for open-source project.

Why Participate?
Learn and Grow: Contributing to open-source projects is a cool way to hone your technical skills, get real-world experience, improve your Git and GitHub skills, and learn how to collaborate with other developers.
You connect, share knowledge, and even collaborate on projects under the mantle of Hacktoberfest, part of a global community.

Give back: The open-source community gives so much to the world Hacktoberfest is your chance to give back by improving and supporting the projects that shape our digital landscape.
You can also donate to open-source projects by supporting their work. Here is the link to Donate, search the project you want to support and donate it.

All the participants will be awarded with a digital badge. It is an opportunity to contribute back to the open source community which helps us to learn more new skills with like-minded people.

Let's appreciate the power of collaboration, code, and community.
Happy hacking!
🦄 ❤️