DEV Community: Mohammad Ali Abdul Wahed

I Built an AI Agent Showcase with Laravel AI SDK — Here’s How You Can Do It

Mohammad Ali Abdul Wahed — Fri, 06 Feb 2026 20:41:47 +0000

How Laravel’s new AI SDK makes building production-ready AI features surprisingly simple (with mock mode for instant demos)
Yesterday, Laravel released their official AI SDK. As someone who’s been watching the AI integration space closely, I knew this was going to be a game-changer for PHP developers.
So I did what any excited developer would do at 11 PM: I built a complete showcase application in one night.

The result? A fully functional AI agent with chat, image generation, text-to-speech, and vector search — all working in your browser right now, no API keys required.

🔗 Live Demo: https://laravel-ai-showcase.onrender.com/
💻 GitHub: https://github.com/aliabdm/laravel-ai-showcase

Here’s exactly how I built it, and how you can do the same.

The Problem with AI Integration
Let me be honest: integrating AI into applications has traditionally been a pain. You’re juggling multiple SDKs, managing API credentials, handling streaming responses, dealing with rate limits, and building fallback systems.

Most developers want to experiment with AI features, but the barrier to entry is high. You need API keys, credit cards, and often hours of setup before you can even see your first result.

Laravel’s AI SDK solves this brilliantly.

What We’re Building
A complete AI showcase with:

✨ AI Chat with real-time streaming
🎨 Image Generation
🔊 Text-to-Speech
🔍 Vector Search with embeddings
🎯 Mock Mode — try everything without API keys
🔄 Session-based mode switching for instant demos
Step 1: Project Setup & Installation
Let’s start fresh:

Create new Laravel project

laravel new ai-showcase
cd ai-showcase

Install Laravel AI SDK

composer require laravel/ai

Publish configuration

php artisan vendor:publish --tag=ai-config
The configuration is beautifully simple:

// config/ai.php
return [
'mode' => env('AI_MODE', 'mock'), // 'mock' or 'real'

'providers' => [
    'gemini' => [
        'api_key' => env('GEMINI_API_KEY'),
    ],
    'openai' => [
        'api_key' => env('OPENAI_API_KEY'),
    ],
],

];
Step 2: The Secret Sauce — Mock Provider
Here’s what makes this project special: a Mock Provider that lets anyone try the app instantly.

Become a member
No API keys. No setup. Just immediate results.

// app/Ai/Providers/MockProvider.php
namespace App\Ai\Providers;
class MockProvider
{
public function text(string $prompt): string
{
return "Hello! I'm a mock AI assistant. You asked: {$prompt}";
}

public function streamText(string $prompt): \Generator
{
    $response = $this->text($prompt);
    $words = explode(' ', $response);

    foreach ($words as $word) {
        yield $word . ' ';
        usleep(100000); // 100ms delay for realistic streaming
    }
}

public function image(string $prompt): object
{
    return (object) [
        'url' => 'https://placehold.co/600x400?text=' . urlencode($prompt),
        'prompt' => $prompt,
    ];
}

}
This simple class saves hours of API setup and makes the app instantly demoable.

Step 3: Smart Mode Switching
Users need to switch between Mock and Real modes seamlessly. Here’s how:

// app/Http/Middleware/AiModeMiddleware.php
namespace App\Http\Middleware;
class AiModeMiddleware
{
public function handle($request, $next)
{
if ($request->session()->has('ai_mode')) {
config(['ai.mode' => $request->session()->get('ai_mode')]);
}

    return $next($request);
}

}
And the controller:

// app/Http/Controllers/ModeController.php
class ModeController extends Controller
{
public function switch(Request $request)
{
$request->validate(['mode' => 'required|in:mock,real']);

    $request->session()->put('ai_mode', $request->mode);

    return response()->json([
        'success' => true,
        'mode' => $request->mode,
        'message' => "Switched to {$request->mode} mode"
    ]);
}

}
Users can now toggle modes with a single click. No server restart needed.

Step 4: Building AI Features
Chat Feature
public function chat(Request $request)
{
$request->validate(['message' => 'required|string']);

if (config('ai.mode') === 'mock') {
    $response = $this->mockProvider->text($request->message);
} else {
    $response = \Laravel\Ai\Facades\Ai::text($request->message);
}

return response()->json([
    'response' => (string) $response,
    'mode' => config('ai.mode')
]);

}
Image Generation
public function generateImage(Request $request)
{
$request->validate(['prompt' => 'required|string']);

if (config('ai.mode') === 'mock') {
    $image = $this->mockProvider->image($request->prompt);
} else {
    $image = \Laravel\Ai\Facades\Ai::image($request->prompt)
        ->landscape()
        ->generate();
}

return response()->json(['url' => $image->url]);

}
Text-to-Speech
public function textToSpeech(Request $request)
{
$request->validate(['text' => 'required|string']);

if (config('ai.mode') === 'mock') {
    $audio = $this->mockProvider->audio($request->text);
} else {
    $audio = \Laravel\Ai\Facades\Ai::audio($request->text)
        ->female()
        ->generate();
}

return response()->json(['url' => $audio->url]);

}
Notice the pattern? Every feature checks the mode and gracefully switches between mock and real AI.

Step 5: Real-Time Streaming (The Highlight!)
This is where it gets exciting. Real-time streaming makes AI responses feel instant and modern:

// app/Http/Controllers/StreamingController.php
public function streamWords(Request $request)
{
$request->validate(['prompt' => 'required|string']);

return response()->stream(function () use ($request) {
    $provider = config('ai.mode') === 'mock' 
        ? $this->mockProvider 
        : null;

    if ($provider) {
        foreach ($provider->streamText($request->prompt) as $chunk) {
            echo "data: " . json_encode(['chunk' => $chunk]) . "\n\n";
            ob_flush();
            flush();
        }
    } else {
        $stream = \Laravel\Ai\Facades\Ai::stream($request->prompt);
        foreach ($stream as $chunk) {
            echo "data: " . json_encode(['chunk' => (string) $chunk]) . "\n\n";
            ob_flush();
            flush();
        }
    }

    echo "data: " . json_encode(['done' => true]) . "\n\n";
}, 200, [
    'Content-Type' => 'text/event-stream',
    'Cache-Control' => 'no-cache',
]);

}
Frontend JavaScript to consume the stream:

async function streamResponse(prompt) {
const response = await fetch('/streaming/words', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'X-CSRF-TOKEN': document.querySelector('meta[name="csrf-token"]').content
},
body: JSON.stringify({ prompt })
});

const reader = response.body.getReader();
const decoder = new TextDecoder();
let output = document.getElementById('output');
output.textContent = '';

while (true) {
    const { done, value } = await reader.read();
    if (done) break;

    const chunk = decoder.decode(value);
    const lines = chunk.split('\n');

    lines.forEach(line => {
        if (line.startsWith('data: ')) {
            const data = JSON.parse(line.slice(6));
            if (data.chunk) {
                output.textContent += data.chunk;
            }
        }
    });
}

}
Users see responses appear word-by-word in real-time. The UX improvement is dramatic.

Step 6: Vector Search with Embeddings
For semantic search capabilities:

// Migration
Schema::create('articles', function (Blueprint $table) {
$table->id();
$table->string('title');
$table->text('content');

if ($this->vectorAvailable()) {
    $table->vector('embedding', dimensions: 768)->index();
} else {
    $table->text('embedding')->nullable();
}

$table->timestamps();

});
Search implementation:

public function semanticSearch(Request $request)
{
$request->validate(['query' => 'required|string']);

if (config('ai.mode') === 'mock') {
    return response()->json([
        'results' => [
            ['title' => 'Mock Result', 'content' => 'Related to: ' . $request->query],
        ]
    ]);
}

$results = Article::query()
    ->whereVectorSimilarTo('embedding', $request->query)
    ->limit(10)
    ->get();

return response()->json(['results' => $results]);

}
Step 7: Bulletproof Error Handling
Production apps need graceful degradation:

private function shouldUseMock(): bool
{
return config('ai.mode') === 'mock'
|| !class_exists('Laravel\Ai\Facades\Ai')
|| !$this->hasApiKeys();
}
private function hasApiKeys(): bool
{
return !empty(env('GEMINI_API_KEY'))
|| !empty(env('OPENAI_API_KEY'));
}
// In controllers
try {
if ($this->shouldUseMock()) {
$response = $this->mockProvider->text($prompt);
} else {
$response = \Laravel\Ai\Facades\Ai::text($prompt);
}

return response()->json([
    'success' => true,
    'response' => $response,
    'mode' => $this->shouldUseMock() ? 'mock' : 'real'
]);

} catch (\Exception $e) {
return response()->json([
'success' => false,
'error' => $e->getMessage(),
], 500);
}
The app never breaks. It always falls back gracefully.

Step 8: Testing Everything
// tests/Feature/AiShowcaseTest.php
class AiShowcaseTest extends TestCase
{
/** @test */
public function mock_mode_works_without_api_keys()
{
config(['ai.mode' => 'mock']);

    $response = $this->postJson('/chat/demo', [
        'message' => 'Hello world'
    ]);

    $response->assertStatus(200)
        ->assertJson(['success' => true, 'mode' => 'mock']);
}

/** @test */
public function mode_switching_works_via_session()
{
    $response = $this->postJson('/ai/mode/switch', ['mode' => 'real']);

    $response->assertStatus(200);
    $this->assertEquals('real', session('ai_mode'));
}

}
Run tests:

php artisan test --filter AiShowcaseTest
Key Lessons Learned

Mock Mode is Essential Lets anyone try your app instantly Zero API costs during development Deterministic responses for testing Perfect for demos and documentation
Session-Based Switching is Powerful Users toggle modes without server restart Great for A/B testing Clear visual feedback builds trust
Streaming Transforms UX Users see responses immediately Perceived performance is dramatically better Modern users expect real-time feedback
Graceful Degradation is Non-Negotiable Always have a fallback Never break the user experience Clear error messages help debugging What We Built ✅ Complete AI Showcase with 4 core features ✅ Dual Mode System (Mock/Real) for flexibility ✅ Real-time Streaming with Server-Sent Events ✅ Session-based Switching for instant demos ✅ Comprehensive Testing with full coverage ✅ Production Ready with proper error handling

Try It Yourself
git clone https://github.com/aliabdm/laravel-ai-showcase.git
cd laravel-ai-showcase
composer install
cp .env.example .env
php artisan key:generate
php artisan serve

Visit http://localhost:8000

All features work immediately in Mock Mode!

Live Demo: https://laravel-ai-showcase.onrender.com/
(Note: It’s on Render free tier, so first load may take a minute)

Conclusion
The Laravel AI SDK makes building AI-powered applications incredibly simple. What would have taken days of integration work now takes hours.

By implementing Mock Mode, session-based switching, and real-time streaming, we’ve created a showcase that:

Works instantly for demos
Scales to production
Provides excellent developer experience
Teaches best practices
The key lesson? Always build with both development and production in mind. Mock modes and graceful fallbacks aren’t just nice-to-have — they’re essential for professional AI applications.

What’s Next?
I’m planning follow-up articles on:

Deploying with Docker
Performance optimization techniques
Extending with custom AI tools
Production security considerations
Monitoring and logging AI usage
Want the complete code? Check out the repository and star it if you find it useful!

Questions? Drop them in the comments — I’d love to help you build your own AI showcase!

Built with ❤️ using Laravel AI SDK
GitHub:
Mohammad Ali Abdul Wahed

Firebase vs Supabase: Why I Switched for PostgreSQL and Cheaper Real-time

Mohammad Ali Abdul Wahed — Fri, 16 Jan 2026 14:19:58 +0000

If you’re a developer, you’ve definitely heard of Firebase—Google’s powerhouse Backend-as-a-Service (BaaS). It has been the industry standard for years. However, as projects scale, many developers (myself included) start looking for something more flexible and, frankly, more affordable.

Recently, I hit a wall with a project. I had two non-negotiable requirements: I needed a robust PostgreSQL database without the "cloud tax," and I needed a real-time solution that wouldn't bankrupt me as my user base grew. This led me straight to Supabase.

Here is my honest comparison and the reasons why I believe Supabase is winning the battle for modern developers.

1. The Database: NoSQL vs. The Power of SQL

The biggest shift when moving from Firebase to Supabase is the underlying architecture.

Firebase (Firestore):
It’s a NoSQL document store. While it's great for simple data, it becomes a nightmare when you need complex relations. You often end up "denormalizing" data or doing multiple nested queries that increase your costs.

Supabase (PostgreSQL):
This was the primary reason I made the switch. Supabase gives you a full PostgreSQL instance. For my project, getting a high-performance relational database for free (on the basic tier) was a game-changer. I could use joins, views, and complex filters that are simply impossible or too expensive in Firestore.

2. Real-Time: Better, Faster, and Significantly Cheaper

There is a common misconception that Firebase is the only king of Real-time. In my experience, Supabase Real-time is not only a viable alternative but often a better one.

Why Supabase Real-time impressed me:
The Cost Factor: In Firebase, every real-time listener and every data sync counts as a "document read." If you have 1,000 users watching a list, your bill explodes. In Supabase, you aren't charged per "read" operation. You pay for bandwidth, which is significantly cheaper.

Postgres Changes: Supabase listens to the PostgreSQL Write-Ahead Log (WAL). This means you can subscribe to specific events (INSERT, UPDATE, DELETE) directly on your database tables.

**Broadcast & Presence: **This is where I saved the most. Supabase allows you to send messages between clients (Broadcast) and track who is online (Presence) without writing any data to the database. It’s low-latency and incredibly cost-effective.

JavaScript

// Supabase Real-time is clean and efficient
const channel = supabase .channel('room-1') .on('postgres_changes', { event: 'INSERT', schema: 'public', table: 'messages' }, payload => { console.log('New message received!', payload.new.text) }) .subscribe()

3. Pricing: Escaping the "Success Tax"

We’ve all heard the horror stories of Firebase "Bill Shocks." Firebase’s pay-per-read model means that if your app goes viral, you might wake up to a $5,000 bill.

The Comparison:
Firebase: You pay for every single operation. Read a document? Pay. Write a document? Pay. It’s hard to predict your monthly costs.

Supabase: They offer a generous Free Tier (which includes that free Postgres DB I needed). Their Pro Plan is a flat $25/month, which covers most of what an MVP needs with very predictable overage costs.

My real-world experience: For a medium-sized app with high traffic, I found that Supabase can be 75% to 80% cheaper than Firebase, mainly because I wasn't being penalized for every database fetch.

4. No Vendor Lock-in

One of the most liberating things about Supabase is that it’s Open Source.

Firebase is a closed Google product. If they raise prices or shut down a service (like they have in the past), you are stuck.

Supabase is built on open tools. If you ever decide to leave their cloud platform, you can take your PostgreSQL database and self-host it anywhere. That peace of mind is priceless.

Final Verdict: Which should you choose?
Stick with Firebase if:

You are building a mobile-first app that requires extremely complex offline-syncing out of the box.

You are deeply integrated into the Google Cloud ecosystem.

*Switch to Supabase if:
*
You want PostgreSQL: You need the reliability and power of a relational database.

You need "Cheap" Real-time: You want to scale your real-time features without worrying about "per-operation" costs.

You want predictable billing: You prefer a flat monthly fee over a "guessing game" bill.

My Experience?
I came for the free PostgreSQL, but I stayed for the Real-time performance and the fair pricing. Supabase has proven that you don't have to sacrifice power for price.

Have you tried Supabase yet, or are you still loyal to Firebase? Let’s discuss in the comments!

AI Orchestration: The Microservices Approach to Large Language Models

Mohammad Ali Abdul Wahed — Sat, 03 Jan 2026 13:01:28 +0000

Stop Asking “Which AI is Best?” Start Asking “How Do I Orchestrate Them?”
As engineers building AI systems in 2025, we’re witnessing a fundamental shift in how we approach artificial intelligence integration. The question is no longer “Should I use GPT, Claude, or Gemini?” but rather “How do I orchestrate multiple specialized models to build robust AI systems?”

This article explores why AI orchestration is the future of intelligent systems and how to implement it effectively.

The Monolithic AI Fallacy
Remember when we built monolithic applications? Everything in one massive codebase, tightly coupled, hard to scale, and impossible to maintain. Then microservices revolutionized software architecture by breaking systems into specialized, independent services.

We’re at that exact inflection point with AI systems.

The industry has been caught in a trap: comparing models head-to-head as if one must reign supreme. “GPT-5 beats Claude!” or “Claude is better at coding!” These comparisons miss the point entirely.

The Reality Check
No single model excels at everything. Each Large Language Model (LLM) has been optimized for different tasks, trained on different data, and architected with different trade-offs. Trying to find one “best” model is like trying to find the one “best” database — it doesn’t exist because the answer depends on your use case.

The 2025 AI Landscape: Specialized Models for Specialized Tasks
Let’s break down the current state of leading AI models and their sweet spots:

Claude (Sonnet 4.5 / Opus 4)
Strengths:

Complex code generation: Claude excels at understanding intricate codebases and generating sophisticated solutions
Long-context processing: With context windows up to 200K tokens, it handles extensive documents and conversations
Technical depth: Superior performance on tasks requiring deep technical understanding
Best for:

Software development and code review
Technical documentation analysis
Long-form content creation
Complex reasoning chains
GPT-5 (OpenAI)
Strengths:

Advanced reasoning: Exceptional at multi-step logical reasoning and problem decomposition
Mathematical prowess: Superior performance on mathematical and scientific tasks
Analytical depth: Strong at breaking down complex problems into structured solutions
Best for:

Scientific research and analysis
Mathematical problem-solving
Strategic planning and decision-making
Educational tutoring
Gemini 3 Flash (Google)
Strengths:

Speed: Fastest inference times among major models
Cost-effectiveness: Significantly lower costs per token
Real-time capabilities: Optimized for streaming and interactive applications
Best for:

Customer service chatbots
Real-time translation
High-volume, low-complexity tasks
Mobile and edge applications
Open Source (LLaMA 3, DeepSeek, Mixtral)
Strengths:

Privacy: Complete data control with local deployment
Customization: Fine-tune for specific domains and use cases
Cost control: No per-token fees for self-hosted deployments
Compliance: Meet strict regulatory requirements
Best for:

Healthcare and financial services
Government and defense applications
Proprietary research
Specialized domain adaptation
Introducing AI Orchestration
AI Orchestration is the practice of intelligently routing tasks to the most appropriate model based on the requirements of each specific task. Think of it as a conductor leading an orchestra — each instrument (model) plays its part when needed to create a harmonious result.

The Architecture
User Request
↓
[Request Analyzer]
↓
[Routing Logic]
↓
┌────────┬────────┬────────┬────────┐
│ Claude │ GPT │ Gemini │ Local │
│ │ │ │ Model │
└────────┴────────┴────────┴────────┘
↓
[Response Aggregator]
↓
Final Response

Key Components
Request Classification: Analyze incoming requests to determine:

Complexity level
Domain (code, math, general, etc.)
Latency requirements
Privacy sensitivity
Cost constraints
Intelligent Routing: Direct each request to the optimal model based on:

Model capabilities and benchmarks
Current load and availability
Cost optimization rules
Privacy and compliance requirements
Response Handling: Process model outputs through:

Validation and quality checks
Format standardization
Error handling and fallbacks
Caching for efficiency
Feedback Loop: Continuously improve routing decisions based on:

Response quality metrics
User satisfaction scores
Performance analytics
Cost tracking
Implementation Patterns
Pattern 1: Task-Based Routing
Route based on the nature of the task:

def route_request(task):
if task.type == "code_generation":
return claude_api
elif task.type == "math_problem":
return gpt_api
elif task.type == "quick_query":
return gemini_api
elif task.is_sensitive_data:
return local_model
Pattern 2: Cascading Intelligence
Start with faster/cheaper models, escalate to more powerful ones:

def cascading_request(query):
response = gemini_api.query(query)

if response.confidence < 0.7:
    response = gpt_api.query(query)

if response.confidence < 0.9:
    response = claude_api.query(query)

return response

Pattern 3: Parallel Processing with Consensus
Query multiple models and aggregate results:

async def consensus_query(question):
responses = await asyncio.gather(
claude_api.query(question),
gpt_api.query(question),
gemini_api.query(question)
)

return aggregate_responses(responses)

Pattern 4: Specialized Pipelines
Chain models for complex workflows:

def content_pipeline(raw_data):
# Fast extraction
structured_data = gemini_api.extract(raw_data)

# Deep analysis
insights = gpt_api.analyze(structured_data)

# Technical implementation
code = claude_api.generate_code(insights)

return code

Real-World Use Cases
Case Study 1: Customer Support Platform
Challenge: Handle 10,000+ daily support tickets with varying complexity

Solution:

Gemini Flash: Handle 80% of simple queries (password resets, status checks)
GPT-5: Process 15% of medium complexity issues (troubleshooting, explanations)
Claude Opus: Resolve 5% of complex technical problems (bug analysis, system integration)
Results:

70% cost reduction compared to single-model approach
40% faster average response time
25% improvement in customer satisfaction
Case Study 2: Healthcare AI Assistant
Challenge: Provide medical information while maintaining HIPAA compliance

Solution:

Local LLaMA model: Process all patient data on-premises
Claude: Generate detailed medical documentation
GPT-5: Analyze research papers and clinical guidelines
Gemini: Handle appointment scheduling and basic queries
Results:

Full HIPAA compliance with local data processing
Comprehensive medical knowledge through specialized routing
Scalable system handling 100K+ monthly interactions
Case Study 3: Development Environment
Challenge: Create an AI coding assistant that handles diverse tasks

Solution:

Claude: Primary code generation and review
GPT-5: Explain complex algorithms and architectural decisions
DeepSeek: Fast code completion and suggestions
Gemini: Quick documentation lookups
Results:

60% increase in developer productivity
Better code quality through specialized review
Reduced API costs by 50%
Benchmarking and Evaluation
To build effective AI orchestration, you need reliable benchmarks. Here are the essential resources:

LMSYS Chatbot Arena URL: https://lmarena.ai

The most comprehensive community-driven benchmark, featuring:

Head-to-head model comparisons
Real user evaluations
Category-specific rankings (coding, math, creative writing)
Regular updates with new models

Artificial Analysis URL: https://artificialanalysis.ai

Focuses on practical metrics:

Response speed comparisons
Cost per token analysis
Context window capabilities
Quality-price ratio evaluations

Open LLM Leaderboard URL: https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard

Become a member
Essential for open-source models:

Standardized evaluation metrics
Academic benchmarks (MMLU, HellaSwag, TruthfulQA)
Model size and efficiency data
Fine-tuning information
Key Metrics to Track
When orchestrating models, monitor these metrics:

Task Success Rate: Percentage of successfully completed tasks per model
Latency: Response time from request to completion
Cost Per Task: Total API costs divided by number of requests
Quality Score: User satisfaction or automated quality metrics
Error Rate: Failed requests or low-confidence responses
Token Efficiency: Average tokens used per successful task
Building Your Orchestration Layer
Step 1: Define Your Use Cases
Map out all AI tasks in your application:

What types of requests do you handle?
What are the complexity levels?
What are your latency requirements?
What are your cost constraints?
What are your privacy requirements?
Step 2: Establish Baseline Benchmarks
Test each potential model on your actual workload:

Create a representative test set (100+ examples)
Measure quality, speed, and cost for each model
Identify each model’s strengths and weaknesses
Document decision rules
Step 3: Implement Smart Routing
Start simple, iterate complex:

class AIOrchestrator:
def init(self):
self.models = {
'claude': ClaudeAPI(),
'gpt': OpenAIAPI(),
'gemini': GeminiAPI(),
'local': LocalModel()
}
self.router = RequestRouter()

def process(self, request):
    # Classify request
    classification = self.router.classify(request)

    # Select optimal model
    model_name = self.router.select_model(classification)
    model = self.models[model_name]

    # Execute with fallback
    try:
        response = model.generate(request)
        self.log_metrics(model_name, request, response)
        return response
    except Exception as e:
        return self.fallback_chain(request, [model_name])

Step 4: Monitor and Optimize
Implement comprehensive observability:

Log every request and response
Track costs in real-time
Monitor quality metrics
A/B test routing rules
Continuously refine your decision logic
Common Pitfalls and How to Avoid Them
Pitfall 1: Over-Engineering
Problem: Building overly complex routing logic from day one

Solution: Start with simple rules based on task type, add complexity only when data shows it’s needed

Pitfall 2: Ignoring Costs
Problem: Not tracking per-request costs until the bill arrives

Solution: Implement cost tracking from day one, set budgets per model, use caching aggressively

Pitfall 3: No Fallback Strategy
Problem: Single point of failure when primary model is down or rate-limited

Solution: Always have 2–3 fallback models configured with automatic failover

Pitfall 4: Static Routing Rules
Problem: Set routing rules once and never update them

Solution: Regularly review performance data, update rules based on new benchmarks, adapt to model improvements

Pitfall 5: Neglecting Privacy
Problem: Sending sensitive data to external APIs without proper safeguards

Solution: Classify data sensitivity, use local models for sensitive data, implement proper data anonymization

The Economics of AI Orchestration
Cost Optimization Strategies
Tiered Routing: Use cheaper models for simpler tasks

Gemini Flash: $0.10 per 1M tokens
Claude Sonnet: $3.00 per 1M tokens
Claude Opus: $15.00 per 1M tokens
Caching: Store and reuse responses for common queries

Reduce API calls by 40–60%
Sub-millisecond response times
Minimal infrastructure costs
Batch Processing: Group similar requests for efficiency

10–30% cost reduction through batching
Better resource utilization
Improved throughput
Hybrid Deployment: Mix cloud and local models

Zero marginal cost for local inference
Control over data and privacy
Backup during API outages
ROI Analysis
For a typical application processing 1M requests/month:

Single Model Approach (Claude Opus only):

Cost: ~$15,000/month
Average latency: 3 seconds
Quality: 95%
Orchestrated Approach:

Cost: ~$6,000/month (60% reduction)
Average latency: 1.5 seconds (50% faster)
Quality: 96% (through specialized routing)
Break-even: Immediate positive ROI

Future Trends in AI Orchestration

Automated Model Selection ML models that learn optimal routing decisions:

Reinforcement learning for routing optimization
Automatic A/B testing of model combinations
Adaptive cost-quality trade-offs

Specialized Model Ecosystems More domain-specific models emerging:

Legal-specific models
Medical-specific models
Financial analysis models
Code-only models

Edge AI Orchestration Extending orchestration to edge devices:

On-device models for privacy
Cloud models for complex tasks
Intelligent data sync

Multimodal Orchestration Routing across different modalities:

Text models for language tasks
Vision models for image analysis
Audio models for speech processing
Code models for development
Getting Started Today
Immediate Actions
Audit Your Current AI Usage

What models are you using?
What are your costs?
What are your pain points?
Benchmark Alternatives

Test 2–3 models on your actual workload
Compare quality, speed, and cost
Identify clear winners for specific tasks
Implement Simple Routing

Start with if-else rules
Add logging and metrics
Iterate based on data
Set Up Monitoring

Track costs per model
Measure response quality
Monitor latency
Resources for Learning More
Technical Documentation:

Claude API: https://docs.claude.com
OpenAI API: https://platform.openai.com/docs
Google AI: https://ai.google.dev/docs
Community Resources:

r/LocalLLaMA for open-source models
HuggingFace forums for model discussions
AI engineering blogs and newsletters
Tools and Frameworks:

LangChain for orchestration
LiteLLM for unified APIs
Helicone for observability
Conclusion: The Orchestrated Future
The question “Which AI is best?” is becoming as outdated as “Which database is best?” The answer is always: it depends on your use case.

The future of AI systems is orchestration. Just as modern software architecture embraces microservices, API gateways, and polyglot persistence, modern AI systems must embrace model diversity, intelligent routing, and specialized capabilities.

The engineers who will build the most successful AI products aren’t the ones who pick the “best” model — they’re the ones who know how to orchestrate multiple models into cohesive, efficient, and powerful systems.

Start thinking like an orchestra conductor, not a solo performer.

The baton is in your hands. What will you create?

About Benchmarking Resources
Throughout this article, I’ve referenced three critical benchmarking platforms that should be part of every AI engineer’s toolkit:

LMSYS Chatbot Arena (lmarena.ai): Community-driven, real-world evaluations
Artificial Analysis (artificialanalysis.ai): Cost and performance metrics
Open LLM Leaderboard (huggingface.co): Academic benchmarks and open-source focus
These platforms are continuously updated as new models are released. Make checking them a regular part of your development workflow.

BTLM
Have you implemented AI orchestration in your systems? Share your experiences in the comments below!

I Built a PDF Chat App in Under an Hour Using RAG- Here's How You Can Too

Mohammad Ali Abdul Wahed — Mon, 29 Dec 2025 09:36:33 +0000

🔗 Live Demo:
https://pdf-chat-rag-fx5nczbrwczzpou6qyczmj.streamlit.app/
📦 GitHub Repo:
https://github.com/aliabdm/pdf-chat-rag
🤔 The Idea
Ever wished you could talk to your documents instead of endlessly scrolling through pages?
That’s exactly what I built using Retrieval-Augmented Generation (RAG) and modern GenAI tools.
Upload a PDF → ask questions → get accurate, context-aware answers in seconds.
❌ The Problem
We’ve all been there:

50-page research papers
Long contracts
Dense technical docs
CVs in recruitment workflows

Ctrl + F isn’t enough when you need:

Summaries
Cross-section answers
Simple explanations
Context-aware responses

✅ The Solution: PDF Chat with RAG
I built a web app that lets you:

Upload any PDF
Ask questions in natural language
Get answers grounded only in your document

👉 Try it live:
https://pdf-chat-rag-fx5nczbrwczzpou6qyczmj.streamlit.app/
🧱 Tech Stack (Why Each Tool Matters)
🧩 LangChain — The RAG Backbone
LangChain makes RAG production-ready by handling:

Document chunking
Embeddings
Retrieval + generation orchestration

Pythonfrom langchain_text_splitters import RecursiveCharacterTextSplitter

text_splitter = RecursiveCharacterTextSplitter(
chunk_size=1000,
chunk_overlap=200
)

chunks = text_splitter.split_text(text)
⚡ Groq — Lightning-Fast LLM Inference
Groq uses custom LPU hardware and delivers:

~2s response time
Models like Llama 3.3 70B
Generous free tier

Pythonfrom langchain_groq import ChatGroq

llm = ChatGroq(
model_name="llama-3.3-70b-versatile",
temperature=0,
groq_api_key=api_key
)
🔍 FAISS — Vector Similarity Search
When your PDF becomes 100+ chunks, FAISS finds the most relevant ones fast.
Pythonfrom langchain_community.vectorstores import FAISS

vector_store = FAISS.from_texts(chunks, embeddings)
🎨 Streamlit — UI in Minutes
Why Streamlit?

No frontend boilerplate
Built-in chat + file upload
Free deployment

Pythonimport streamlit as st

uploaded_file = st.file_uploader("Upload PDF", type=["pdf"])

if question := st.chat_input("Ask a question"):
pass
🧠 HuggingFace Embeddings
We use all-MiniLM-L6-v2:

Fast
High quality
Runs locally
No API cost

Pythonfrom langchain_community.embeddings import HuggingFaceEmbeddings

embeddings = HuggingFaceEmbeddings(
model_name="sentence-transformers/all-MiniLM-L6-v2"
)
🔄 How RAG Works (Simple Breakdown)
Phase 1 — Document Processing

Upload PDF
Extract text
Split into chunks
Generate embeddings
Store in FAISS

Phase 2 — Question Answering

Embed the question
Retrieve top 3 relevant chunks
Build context
Send to LLM
Return grounded answer

Pythondocs = vector_store.similarity_search(question, k=3)

context = "\n\n".join([doc.page_content for doc in docs])

prompt = f"""
Context:
{context}

Question:
{question}

Answer ONLY based on the context above.
"""

answer = llm.invoke(prompt)
🧪 Core RAG Logic (That’s It)
Pythondef answer_question(question, vector_store, llm):
docs = vector_store.similarity_search(question, k=3)
context = "\n\n".join([doc.page_content for doc in docs])

prompt = ChatPromptTemplate.from_template("""
Context: {context}
Question: {question}

Provide a detailed answer based on the context.
""")

chain = prompt | llm | StrOutputParser()
return chain.invoke({"context": context, "question": question})

🧠 Key Design Decisions

Chunk overlap: avoids cutting context
Temperature = 0: deterministic answers
k = 3 chunks: best speed/accuracy balance

⚠️ Challenges & Fixes
PDF Text Extraction
Some PDFs return broken text.
✔️ Added validation + clear error messages.
Context Window Limits
Large docs exceeded limits.
✔️ Limited chunk size + retrieval count.
Answer Quality
Early answers were vague.
✔️ Strong prompt constraints.

📊 Performance
Metric,Value
PDF size,50 pages
Processing time,~15s
Response time,~2s
Chunks,87
Accuracy,⭐ 8.5 / 10

🚀 What’s Next?

Multi-PDF support
Conversation memory
Export chat history
Word / TXT support

🧑‍💻 Run It Locally
Bashgit clone https://github.com/aliabdm/pdf-chat-rag pip install -r requirements.txt streamlit run app.py
Deploy on Streamlit Cloud in one click 🚀
🧠 Lessons Learned

RAG is simpler than it looks
Speed > model size
Prompt engineering matters
Start simple, iterate fast

🔚 Final Thoughts
Modern AI is about orchestration, not reinventing tools.
If this helped you, consider giving the repo a ⭐
🔗 Connect With Me

LinkedIn: https://www.linkedin.com/in/mohammad-ali-abdul-wahed-1533b9171/
GitHub: https://github.com/aliabdm
Dev.to: https://dev.to/maliano63717738

Happy coding 🚀

I Built a Free URL Shortener in 4 Hours Using Ruby on Rails - Here's Why Rails Still Rocks in 2025

Mohammad Ali Abdul Wahed — Sun, 28 Dec 2025 19:12:12 +0000

I Built a Free URL Shortener in 48 Hours Using Ruby on Rails — Here's Why Rails Still Rocks in 2025

The Problem That Started It All

Yesterday, I was working on an article about my Elixir project. I needed to share multiple long URLs in the post, so naturally, I reached for a popular URL shortening service.

Three clicks later, I hit a wall: "You've reached your limit of 3 short links this month."

As a developer, this felt wrong. Why should something as simple as shortening URLs be locked behind paywalls and limits?

So I did what any developer would do: I built my own.

48 hours later, I had a fully functional, free, open-source URL shortener deployed and running.

Why Ruby on Rails?

In 2025, with all the new frameworks and tools out there, why would I choose Rails?

Simple answer: productivity.

Rails is built on the principle of "convention over configuration" — which means less time configuring, more time building. Here's what I got out of the box:

⚡ Speed of Development

rails new url_shortener -d postgresql
rails generate scaffold Link original_url:text short_code:string clicks:integer
rails db:migrate

Three commands. That's it. I had a full CRUD application with:

Database schema
RESTful routes
Controller actions
View templates

🎯 Smart Defaults

Rails made architectural decisions for me, so I could focus on the unique business logic:

class Link < ApplicationRecord
  before_create :generate_short_code

  private

  def generate_short_code
    loop do
      self.short_code = SecureRandom.alphanumeric(6)
      break unless Link.exists?(short_code: short_code)
    end
  end
end

Six lines of code to generate unique short codes. No external libraries needed.

📦 The Ruby Ecosystem

Need QR codes? There's a gem for that:

gem 'rqrcode'

One line in the Gemfile, and suddenly I could generate QR codes for every short link:

RQRCode::QRCode.new(short_url).as_svg

What I Built

The URL shortener includes:

Instant Short Links - Paste a URL, get a short code
Click Analytics - Track how many times each link is clicked
QR Code Generation - Automatic QR codes for every link
No Registration Required - Anyone can use it freely
Clean, Responsive UI - Built with inline CSS (no framework bloat)

The Technical Stack

Backend: Ruby on Rails 8.1
Database: PostgreSQL
QR Codes: rqrcode gem
Deployment: Render (free tier!)
Time to MVP: Less than 48 hours

Why Rails Made This Possible

1. Active Record Is Magic

Rails' ORM (Active Record) turned database operations into elegant Ruby code:

@link = Link.find_by!(short_code: params[:short_code])
@link.increment!(:clicks)
redirect_to @link.original_url

No SQL, no boilerplate — just readable, maintainable code.

2. Database Migrations Are First-Class Citizens

Every schema change is versioned and reversible:

class CreateLinks < ActiveRecord::Migration[8.1]
  def change
    create_table :links do |t|
      t.text :original_url
      t.string :short_code
      t.integer :clicks, default: 0
      t.timestamps
    end
    add_index :links, :short_code, unique: true
  end
end

3. Convention Over Configuration

Rails assumes sensible defaults. Want a redirect route?

get '/:short_code', to: 'links#redirect'

One line. Rails handles the rest.

4. Deployment Is a Breeze

With Render, deploying Rails apps is ridiculously simple:

Connect GitHub repo
Add environment variables
Hit deploy

Rails' convention-based structure means Render knows exactly how to build and run the app.

The Results

Live URL: [Your Deployed URL]
Source Code: [GitHub Repository]

The project is:

✅ 100% free to use
✅ Open source (MIT license)
✅ Deployable in 10 minutes
✅ No registration required
✅ Fully functional with analytics and QR codes

Lessons Learned

1. Rails Still Delivers on Its Promise

After nearly 20 years, Rails remains one of the fastest ways to build web applications. The "Rails way" isn't just convention — it's accumulated wisdom from thousands of production apps.

2. Choose Boring Technology

Rails isn't trendy. It doesn't make headlines at tech conferences. But it works, and it works consistently.

When you need to ship fast, reach for boring, proven technology.

3. Open Source Wins

Instead of paying for limited features, I built exactly what I needed and made it available for everyone. That's the power of open source.

Try It Yourself

The entire project is open source. You can:

Use the live version at [Your Live URL]
Deploy your own in under 10 minutes
Fork and customize to fit your needs
Contribute features via pull requests

Final Thoughts

In 2025, with AI, microservices, and serverless everything competing for our attention, it's easy to overcomplicate things.

Sometimes, the best solution is the simplest one.

Rails gave me superpowers: I went from idea to deployed product in 48 hours, with clean code, zero configuration headaches, and a fully functional app.

That's the Rails magic that keeps me coming back.

What's your experience with Rails? Or what framework do you reach for when you need to ship fast? Let me know in the comments!

Resources

📂 GitHub Repository: https://github.com/aliabdm/url-shortener-rails
🚀 Live Demo: https://url-shortener-rails.onrender.com/links
💼 Connect on LinkedIn:https://www.linkedin.com/in/mohammad-ali-abdul-wahed-1533b9171/
🐙 Follow on GitHub: https://github.com/aliabdm

If you found this helpful, give the project a ⭐ on GitHub!

Built with ❤️ using Ruby on Rails

🚀 PlainAid: Real-Time AI Text Simplifier Built with Elixir & Phoenix LiveView

Mohammad Ali Abdul Wahed — Sat, 27 Dec 2025 13:38:49 +0000

I recently explored Elixir, a trending, high-performance language, and paired it with Phoenix LiveView to build PlainAid 🎯, a privacy-first web app that simplifies complex text instantly.

Why I Chose Elixir & Phoenix LiveView

Elixir: Runs on Erlang VM → handles millions of concurrent connections
Fault-tolerant & scalable → apps stay reliable under load
Phoenix LiveView: Real-time, interactive UI without heavy JavaScript
Elixir + LiveView lets you build real-time web apps quickly, with clean code and high performance.

What PlainAid Does
PlainAid turns complex legal, official, or formal documents into clear, actionable insights:

✅ Simplified Summary
⚠️ Key Actions
⏰ Deadlines
🚨 Risks
✓ Optional Items
All real-time, secure, and privacy-first — no accounts, no data storage.

flowchart TD
User --> LiveView[Phoenix LiveView UI] LiveView --> Simplifier[Text Simplifier Module] Simplifier --> AI[Groq API (Llama 3.3)] AI --> Simplifier Simplifier --> LiveView LiveView --> User

- User inputs text in the web form
- LiveView updates instantly
- Simplifier sends text to AI API
- Returns structured summary & actionable points
- Displayed real-time

Tech Stack

Component	Technology
Language	Elixir 1.19
Framework	Phoenix 1.7 + LiveView
AI Processing	Groq API (Llama 3.3 70B)
HTTP Client	HTTPoison
JSON	Jason
Styling	Tailwind CSS
Deployment	Render.com

Try It Yourself
🔗 Live Demo: https://lnkd.in/dRFc8uMH
📂 GitHub Repo (Open Source — MIT): https://lnkd.in/dPR7YcGC

Why This Matters

Build interactive, real-time apps with minimal front-end code
Scalable & fault-tolerant → handles growth effortlessly
Privacy-first design → perfect for sensitive documents

Ideas for Contribution
Multi-language support (Arabic, Spanish, French)
Browser extension
Export results to PDF/DOCX
Batch processing of documents
Enhanced AI summarization
📢 PlainAid is live & ready for testing!

Give it a try, fork the repo, or contribute. Let’s make reading complex text simple for everyone.

Redis Hacks Your Future Self Will Thank You For 🚀 (No More Crashes, Slowdowns, or "Why Is Production Burning?!" Nights)

Mohammad Ali Abdul Wahed — Wed, 16 Apr 2025 16:36:48 +0000

Redis isn’t just a fancy cache – it’s a grenade. Pull the wrong pin (ahem, maxmemory), and BOOM 💥

maxmemory & Eviction Policies: Stop Redis From Ghosting Your Data

The Problem: Redis doesn’t magically clean up. Set maxmemory too high, and it’ll eat your RAM like a Cookie Monster. Set it too low, and it’ll evict data mid-transaction.

The Fix:
First: set the max memory limit that Redis can't exceed out of your server resources
Use the eviction strategy option that meets your needs. Example:
volatile-lru for mixed workloads (bye-bye, least-recently-used expired keys).

allkeys-lfu if you’re a data hoarder (prioritize frequently used keys, even if they’re immortal).

All options:

Pro Tip: Test evictions before your app trends on Hacker News.

Lua Scripts: Your Atomic Weapon Against Race Conditions

Why It Matters: 5 clients updating the same key? Chaos. Lua scripts execute atomically.

Later, you can pull your data from Redis into whatever DB you use for consistency.

Retries, Timeouts & Processors (Yes, That’s a Word Now)

- Retries: 3 retries with exponential backoff. More? You’re just DDoSing yourself.
- Timeouts: connect_timeout: 5s, read_timeout: 2s. Your app isn’t a hostage negotiator.
- Processors: Redis is single-threaded. If your CPU cores are screaming, shard or migrate heavy ops to background workers.

Redis isn’t ‘set it and forget it’ – it’s ‘set it, tweak it, and make your on-call rotations boring again’. Try one tip today, and thank me when you’re sleeping through deploy windows.

Comment your worst Redis horror story – bonus points for plot twists involving FLUSHALL

Thanks for reading

Understanding When and Why Top Talent Decides to Leave: A Crucial Insight for Employers

Mohammad Ali Abdul Wahed — Tue, 13 Aug 2024 20:48:26 +0000

*Retaining Top Talent: A Critical Insight for Employers
*
Retaining top talent is essential for any organization's success, yet there are critical moments when even the most competent and loyal employees decide to leave. Recognizing these moments can help companies prevent costly turnover.

**Stage 1: The First Day Disillusionment
**Imagine a new hire who joins with high expectations, only to discover that the reality of the workplace differs significantly from what was portrayed during recruitment. For example, a software developer at a tech company was promised a collaborative environment with cutting-edge projects, only to find a culture of micromanagement and outdated tools. This misalignment led to an early resignation, highlighting the importance of transparency during the hiring process. Even a small deception can erode trust and lead to a quick exit.

**Stage 2: The First Anniversary Without Recognition
**After a year of dedication, employees often expect some form of recognition—whether it's a raise, a promotion, or even a simple acknowledgment of their contributions. A study revealed that a substantial percentage of workers leave because they feel undervalued. For instance, an employee at a financial services firm worked tirelessly, only to receive minimal feedback and no raise. The lack of recognition prompted them to seek opportunities elsewhere, where their efforts would be appreciated.

**Stage 3: The Second Year Stagnation
**By the second year, employees look for growth opportunities. Without new challenges or a clear path for career advancement, they may feel stagnant. A real-life example can be found in a mid-level manager at a retail company who, after two years of routine tasks and no prospects for development, decided to move on to a role that offered growth. The feeling of being "stuck" can be a powerful motivator for leaving, even if other aspects of the job are satisfactory.

**The Consequences of Losing Top Talent
**Losing a key employee can weaken an organization significantly, impacting productivity and morale. Research shows that the departure of just one highly skilled worker can disrupt workflows and lead to unexpected declines in output. Therefore, it's crucial for companies to invest in honest communication, meaningful recognition, and career development to retain their best employees.

Conclusion
Employers must recognize these critical stages and take proactive steps to ensure that their top talent feels valued, challenged, and aligned with the company’s mission. The cost of replacing an experienced employee often far exceeds the cost of keeping them engaged and satisfied.

Data Encryption

Mohammad Ali Abdul Wahed — Thu, 02 May 2024 17:23:56 +0000

Unlocking the Mystery: What is Data Encryption and How Does it Work? 🔐

Ever wondered how your sensitive information stays safe online? Let's dive into the world of data encryption and understand its inner workings, along with when to use each method and which algorithms to choose.

Data encryption is like turning readable data into a secret code, ensuring security, authenticity, and integrity. But why do we need it?

Three main reasons:

Security: Protecting important data from exposure
Authenticity: Ensuring only authorized individuals can access the data
Integrity: Guaranteeing that important data hasn't been tampered with So, what are the types of data encryption?

Firstly, Symmetric Encryption:
This method uses a single key to both encrypt and decrypt data. While algorithms like Blowfish and RC4 are outdated, AES stands as today's best practice.

How does it work?
These algorithms encrypt data bit by bit, with AES dividing data into blocks and adding an Initialization Vector (IV) to generate a unique random value for each block.

But what if the key is compromised? Enter Asymmetric Encryption:
This approach involves a public key to encrypt data and a private key to decrypt it. RSA and Diffie-Hellman are popular examples, safeguarding sensitive communications like SSH connections.

But what about data modification?

Enter the third type: Hashing Functions:
These one-way encryption methods, like SHA and MD5, ensure data integrity. For example, passwords are stored as hashed values, and during login, the hashed input is compared to the stored hashed password.

So, the next time you send a sensitive message or log into your bank account, remember the invisible fortress of encryption standing guard, keeping your information safe and sound.

Integrating With OpenAi(ChatGPT)(With Code example)

Mohammad Ali Abdul Wahed — Fri, 23 Jun 2023 12:13:56 +0000

If your project's requirement puts you in need of integrating it with OpenAi here is a brief depending on OpenAi documentation of how to do that :
First, you need to make your needs clear because OpenAi depends on many models and engines each one of them is an Ai model trained on a specific amount of data and can provide a limited amount of words or types of responses.
Based on the type of response it goes for 2 main categories :
Completion:
In this type, the usage will be for the completing and text you send and as an example of it :
text-davinci-001,text-davinci-002,text-davinci-003
the number in the end represent the accuracy of the response,davinci 3 is the highest.

Chat:
In this type, the usage will be for the Chat and it works 100% the same as you are chatting with Chatgpt, as an example of its models :
gpt-3.5-turbo,gpt-3.5-turbo-0613 ..etc
gpt-3.5-turbo-0613 is the newest one and the one with the highest accuracy,code example:

Note: please note that as much as you raise your accuracy the response time will be higher.

What Is Trait In PHP?

Mohammad Ali Abdul Wahed — Sun, 28 May 2023 14:56:18 +0000

Question asked in every interview: What does trait mean in PHP?
Today's post is about PHP in general and specifically about something we use every day without delving deep into it, which is the trait class. We all know about object-oriented programming and how we can inherit from one class to another. However, sometimes we need to implement multiple inheritance, which means allowing a class to inherit from more than one class. Unfortunately, this feature is not supported in PHP, so we use traits instead.
In the image below, there is an example comparing traits in PHP and the same concept in Python.
In Laravel, all you need to do to use a trait is to start the class definition with the keyword "trait" and import the namespace "App\Traits." Apart from its main purpose, which is solving the problem of multiple inheritances, traits have many other uses, such as in SOLID principles, object-oriented programming, and more.

How Much PHP Do I Need To learn Laravel?

Mohammad Ali Abdul Wahed — Sat, 27 May 2023 15:57:01 +0000

OOP, some PDO would be great addition,know the concept of MVC and how it works, know PHP helpers and main functions, that's it you are good to go