What about India – where 1.4 billion people work across farming, construction, IT, banking, healthcare, and government? Where does AI actually threaten livelihoods, and where is the workforce relatively safe?

I wanted to see this visually. So I built it. Inspired by Andrej Karpathy’s jobs project which analyzed 342 US occupations from BLS data – I built the Indian version using NCS Portal data. You can visit here .

What the map shows

The visualization is an interactive treemap of the Indian job market, covering 10 major sectors and ~500 occupations from the National Career Service portal , India’s official government career database based on NCO-2015 classification.

Each rectangle is one occupation. Two visual signals:

• Size – how many people work in that occupation. A farmer’s rectangle is enormous. A software architect’s is tiny.
• Color – how exposed that occupation is to AI disruption, scored 0–10. Green means relatively safe. Red means high risk.

The picture that emerges is striking, and very different from the American version of this story.

What India’s map actually looks like

Agriculture dominates. Nearly 40% of India’s workforce is in farming – cultivators, dairy workers, livestock farmers. These jobs score 2–3 out of 10 on AI exposure. They require physical presence, seasonal judgment, and local knowledge that AI cannot replicate at scale, especially in India’s fragmented smallholder farming context. The agriculture block is a massive sea of green.

Construction is the second green giant. With 60+ million workers, construction scores 3/10. Masons, welders, electricians, plumbers – physical skills in unpredictable environments that robots still can’t handle reliably. India’s infrastructure boom under Smart Cities and PM Gati Shakti is creating more of these relatively safe jobs.

IT-ITeS is a small red island. India’s famous software and BPO sector employs far fewer people than agriculture – but scores 7–9 out of 10 on AI exposure. Software developers, data analysts, business process managers, content writers – these are exactly the jobs that LLMs are already eating into. The IT block is tiny but blazing red.

BFSI tells a split story. Bank tellers and loan document processors are highly exposed (7–8/10). Relationship managers and wealth advisors are more protected (5/10) because trust still drives financial decisions in India. The branch banking model that employs hundreds of thousands is under significant pressure.

Telecom is surprisingly high risk. Customer care agents, billing processors, network documentation staff – a huge portion of India’s telecom workforce is in roles scoring 7–8/10. Jio disrupted pricing; AI is disrupting the workforce. Tower technicians and field engineers score much lower (3–4/10) because their work is physical.

Logistics is a tale of two workforces. Delivery workers and warehouse staff score low (2–3/10) – physical work, last-mile human judgment. But dispatch coordinators, route planners, and logistics analysts score 6–7/10. Zomato and Swiggy’s gig economy has created millions of AI-safe delivery jobs while quietly automating the planning layer above them.

Organised Retail is in transition. Cashiers and billing staff score high (7/10) – self-checkout and UPI are already replacing them. But floor staff, visual merchandisers, and store managers score moderate (4–5/10). The kirana store owner scores low – hyperlocal relationships and informal credit systems are hard for AI to replicate.

Public Administration scores higher than people expect. Data entry clerks, document processing officers, and administrative assistants in government score 6–7/10. The institutional inertia of Indian bureaucracy will delay automation, but it won’t prevent it. Millions of aspirational government job seekers are training for roles that AI will significantly reshape within a decade.

Healthcare is the interesting middle ground. Doctors and specialists score moderately (5–6/10) because diagnosis and patient relationships still require human judgment. But medical transcriptionists, billing clerks, and hospital administrative staff score 8–9/10. AI will hollow out healthcare administration long before it touches clinical care.

Education sits in the amber zone. With 10 million+ teachers in India, education scores 4–5/10. The human relationship at the core of teaching is protective – but administrative staff, content creators, and exam evaluators score much higher.

The full picture across 10 sectors

The uncomfortable takeaway

India has spent 30 years building an economy on the back of knowledge work IT services, BPO, back-office processing that is precisely what AI automates best. Meanwhile, the jobs employing most Indians farming, construction, delivery are safe not because they’re valuable but because they’re physical and informal.

Construction workers building smart cities. Delivery workers powering e-commerce. Farmers feeding a billion people. All relatively safe from AI.

Software engineers. Bank clerks. Government data entry operators. Call centre agents. All highly exposed.

The map doesn’t have answers. But it makes the question visible.

The post I Built a Map of Which Indian Jobs Are Most at Risk from AI appeared first on NoloWiz.

Docker Model Runner (DMR)

Docker Model Runner (DMR) is a tool built into Docker Desktop and Docker Engine that makes it easy to pull, run, and serve AI/LLM models locally directly from Docker Hub, any OCI-compliant registry, or Hugging Face. Models can be pulled from model resgistry and stored locally.

DMR has the following key features :

• Serves models via OpenAI and Ollama-compatible APIs, so existing apps can plug right in Docker
• Models load into memory only at runtime and unload when not in use to save resources Docker
• Following inference engines are supported
  • llama.cpp (default, all platforms)
  • vLLM (high throughput, NVIDIA)
• Image generation via diffusers
• Integrates with AI coding tools like Cline, Continue, Cursor, and Aider Docker
• Works with Docker Compose and Testcontainers

Step 1: Enable Docker Model Runner

First we need to install docker desktop/ docker by following the getting started docker guide. To enable docker model runner do the following.

Docker Desktop: Go to Settings -> AI tab, then enable Docker Model Runner. Optionally enable GPU-backed inference if you have a supported NVIDIA GPU.

Docker Engine (Linux): Install the plugin, then test it:

sudo apt-get update
sudo apt-get install docker-model-plugin

Now we can verify docker model command by running the below command

docker model version

Step 2: Pull a Model

Next we need to pull a model from Docker Hub.

docker model pull ai/smollm2:360M-Q4_K_M

Or pull directly from HuggingFace:

docker model pull hf.co/bartowski/Llama-3.2-1B-Instruct-GGUF

Models are cached locally after the first pull.

Docker models can be installed using docker desktop as shown below

Step 3: Run the Model

Run the below command to run the model with interactive CLI :

docker model run ai/smollm2:360M-Q4_K_M

How to use Model API

By default, Docker Model Runner may only be accessible via a Unix socket or internal Docker networking. To call it from your host machine (e.g., via curl or Postman), you must explicitly enable TCP host access. As we have enabled this in the docker desktop we can use the API.

For docker CLI use the below command enable it

docker desktop enable model-runner --tcp=12434

Docker Model Runner uses an OpenAI-compatible API, but the path includes the engine and model name. Base URL structure:

• From Host: http://localhost:12434/v1
• From inside a Container: http://model-runner.docker.internal:12434/v1

Testing the API with Postman.

We can connect with OpenAI comptible libraries, here is an example of Python code :

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:12434/engines/v1",
    api_key="not-needed",
)

response = client.chat.completions.create(
    model="ai/smollm2:360M-Q4_K_M", messages=[{"role": "user", "content": "Hello!"}]
)
print(response.choices[0].message.content)

Context Size

The context size is the total token budget for each request, split between what you send in and what the model generates back. As per DMR documentation default context size for the engines :

• llama.cpp – 4096
• vLLM – Uses the model’s maximum trained context size

We can configure the model context size using the below command :

docker model configure --context-size 8192 ai/qwen2.5-coder

When to Use Docker Model Runner

Use docker model runner in the following scenarios.

• Local development & testing – Local development without costly API calls, or privacy concerns from cloud APIs.
• Privacy-sensitive workloads – To keep confidential data fully under your control.
• Docker-native workflows – Use familiar docker model pull/run commands with no new toolchain to learn.
• Multi-container AI apps with Compose – Define models directly in compose.yml alongside your app services with zero extra glue code.
• Offline / edge environments – Run models locally where cloud API access isn’t reliable or allowed.
• CI/CD pipelines – Pull, tag, version, and deploy models like any other artifact, no GPU cluster required

Quick Troubleshooting 

1. To check whether Docker Model Runner (DMR) run the below command :

docker model status

2. To list pulled models use the below command :

docker model ls

3. To display detailed information about a specific model

docker model inspect <model_name>

E.g docker model inspect ai/smollm2:360M-Q4_K_M

4. Test basic connectivity (List Models):

curl http://localhost:12434/v1/models

Conclusion

Docker model runner makes it easier to run AI models locally without much problem and staying with the docker ecosystem. Run Large Language Models Locally with Simple APIs.

The post Run AI Models with Docker Model Runner: A Step-by-Step Guide appeared first on NoloWiz.

Agent Skills

The open Agent Skills standard was introduced by Anthropic. Agent skill is a modular add-on that gives AI agents new abilities, from coding best practices to video editing. Skills are a new open standard for packaging reusable expertise into modular units that any compatible AI agent can discover, load, and apply on demand. Think of them as plugins for your agent’s brain: instead of repeating the same long prompt every time you want your AI to follow your team’s React conventions or generate a proper Dockerfile, you install a skill once and the agent applies it automatically whenever relevant.

Skill Folder Structure

At its core, a skill is simply a directory that contains a SKILL.md file. This file holds essential metadata such as the skill’s name and description along with detailed instructions that guide an agent in completing a specific task.

my-skill/
├── SKILL.md          # Required: instructions + metadata
├── scripts/          # Optional: executable code
├── references/       # Optional: documentation
└── assets/           # Optional: templates, resources

Agent Skills Format

A skill is a directory containing atleast one file called SKILL.md. Optional directories such as scripts/, references/, and assets/ can be added to provide extra functionality and resources for your skill.

SKILL.md file

The SKILL.md file must begin with YAML frontmatter (Frontmatter refers to the introductory section of a document or publication that contains information about the content), followed by the main content written in Markdown.

---
name: skill-name
description: A description of what this skill does and when to use it.
---

The name and description fields are necessary other optional fields includes allowed-tools, metadata,license.

• name – Lowercase letters, numbers, and hyphens only(Max 64 characters) E.g name: code-review
• description – Clear description of what the skill does and when to use it( max 1024 characters)
• license(optional) – The license applied to the skill, e.g – license: Proprietary. LICENSE.txt has complete terms
• allowed-tools(optional) – The space limited allowed tools to use e.g : allowed-tools: Read, Grep
• metadata(optional) – Additional data as key value pair
• compatibility (Optional) – Whether this skill is intended for a particular environment e.g : compatibility: Designed for Claude Code (or similar products)

Finally we have skill body it contains skill instructions. It should have following recommended sections

• Step-by-step instructions
• Examples of inputs and outputs
• Common edge cases

Here is a simple example of SKILL.md file.

---
name : Weather Retriever
description: Fetches real-time weather data and forecasts for any city globally. Use this when the user asks about current conditions or travel planning.
---

## Instructions
1. Extract the `city_name` and `units` (metric/imperial) from the user prompt.
2. If the city is missing, ask for clarification before proceeding.
3. Call the `get_weather_data` function using the extracted parameters.
4. Format the output into a friendly, 2-line summary for the user.

## Tools & Resources
- **Code:** `weather_api_client.py`
- **Data:** `city_codes.json` (for validation)

## Constraints
- Do not provide forecasts beyond 7 days.
- Always include the "Last Updated" timestamp in the response.

Optional directories

• scripts/ – contains executable code that agents can run to perform actions or computations. (Python,Javascript or bash)
• references/ – holds extra documentation and reference files that the agent can read on demand. for example REFERENCE.md for detailed reference
• assets/ – stores static resources like templates, images, or data files used by the skill

How Agent Skills Work

Agent skills has following life cycle :

• Discovery – The agent scans available skills and reads their names and descriptions to understand what capabilities are available.
• Activation – When a task matches a skill’s purpose, the agent loads and reads the full SKILL.md instructions.
• Execution – The agent follows the skill’s instructions, using any scripts, assets, or references required to complete the task.

You can refer the Skills by Anthropic on this GitHub repo.

MCP vs Agent Skills

The key differences between MCP(Model context proctocol) and agent skills are listed below.

Best Practices with Agent skills

Follow these best practices to work with agent skills :

• Create a dedicated folder per skill (e.g., pdf-parsing/) inside a skills/ directory
• Define “When to use” and “How to use” sections in SKILL.md with clear steps, parameters, and examples.
• Keep SKILL.md within 500 lines. If it goes beyond that, evaluate whether some sections should be moved into separate reference files.
• If you are using third party skills , enusre that it does not contains any malicious instructions/code.

When to use Agent Skills

Use agent skills in the following scenarios :

• When tasks are reusable (E.g Web research skill, blog outline generator skill)
• When You want separation between “Brain” and “Tools”, think like this LLM as brain(reasoning) and skills as hands(execution),If your system only needs thinking then no skill needed, if your system needs doing then skills are required
• Avoid skills for one-off tasks (use prompts) or real-time external access (use MCP/tools).

Security Risks

The following secuirty risks are associated with third party agent skills :

• Malicious Code Injection : Third-party skills often bundle executable instructions or scripts (e.g., hidden curl commands in markdown) that AI agents execute blindly, enabling data exfiltration, backdoors, or system compromise without human review
• Privilege Escalation : Skills frequently request excessive permissions—like sudo access, credential stores, or root execution far beyond stated needs, amplifying damage if exploited.

OpenClaw and VirusTotal are now collaborating to scan ClawHub, the marketplace for agent skills. You can also use Skill Scanner by Cisco for free.

skill-scanner scan <skill folder path>

Conclusion

Agent Skills are transforming how AI agents move from simple chatbots to capable task executors. By packaging instructions, tools, and structured workflows into reusable skill modules, you can build agents that are scalable, maintainable, and easier to extend.

The post Agent Skills: Complete Beginner’s Guide to AI Agent Skills and Best Practices appeared first on NoloWiz.

Old photos fade. Scanned images lose clarity. Blurry pictures and damaged memories often feel impossible to fix without expensive software or professional help.

But with advancements in AI, restoring images is no longer limited to tools like Photoshop. Today, you can use powerful prompts inside Gemini, the AI model developed by Google, to enhance, repair, and restore images with simple instructions.

Remove scratches and restore old photo

Old photos often carry priceless memories, but over time they can become damaged with scratches, dust spots, tears, and fading. Whether it’s a black-and-white family portrait or a faded childhood picture, modern Gen AI restoration technology helps bring clarity, sharpness, and life back to your treasured moments in just a few simple steps.

Original photo as shown below :

Use the below prompt to remove scracthes and clear photo and colorize it.

Full professional restoration of this vintage photograph. Remove all damage including tears, fading, scratches, and discoloration. Sharpen facial features and enhance contrast. Output high-resolution

Use the below prompt to remove scratches,tears and fading.

Restore this damaged photograph: Remove all scratches, tears, creases, dust spots, and stains. Repair fading, enhance clarity and sharpness, preserving original mood

Colorize Old Black & White Photos

Black and white photos capture timeless moments, but adding color can make them feel more real and emotionally powerful. With Gemini, you can automatically transform old monochrome images into vibrant, natural-looking photographs. These tools intelligently detect objects, skin tones, clothing, and backgrounds to apply realistic colors while preserving the original details.

We will use this black and white photo for colorization :

Use the below prompt colorize old photos.

Colorize this black and white image realistically.
Use natural skin tones and historically accurate colors.
Avoid artificial saturation.

Upscale Low Resolution Image

Low-resolution images often appear blurry, pixelated, or lacking in detail—especially when viewed on larger screens. With Gemini nano banana, you can enhance image resolution without losing clarity or sharpness.

Restore and enhance this photograph by improving clarity, sharpness, and image quality while preserving all original details, colors, and composition exactly as they appear - remove noise, blur, and degradation artifacts to create a professionally restored HD version that maintains complete authenticity without any artistic interpretation or alterations.

Conclusion

It is easier to restore old photos and colorize them using Gemini AI, thanks to advancements in latest AI technologies.

The post Gemini Prompts for Image Restoration: Fix Old And Blurry Photos Easily appeared first on NoloWiz.

In this post, we’ll explore what the Ollama API is, how it works, and how to use it in real applications.

Ollama is a local AI runtime that lets you run open-source large language models on your own machine. It provides a simple CLI and HTTP API to download, manage, and interact with models privately, offline, and without relying on cloud-based AI services. To learn Essential Ollama Commands read our article.

Installing Ollama

First of all download and install ollam from the official site.

Verify installation:

ollama --version

Run a model in this demo we will use qwen2.5:latest model.

ollama run qwen2.5:latest

Ollama API Basics

Ollama exposes REST APIs ,it can be used with other applications.Ollama exposes a local HTTP server by default at

http://localhost:11434

We can interact with standard REST API calls. If we send a GET request to http://localhost:11434 we will get following response.

Ollama provides following APIs:

• Text generation API
• Chat completion API
• Embedding generation API
• Version API

1. Generate Text with Ollama API

To generate text using ollama API use the below API

POST http://localhost:11434/api/generate

Example request body :

{
"model": "qwen2.5:latest",
"prompt": "Define REST API in 50 words"
}

As we can see that generate API will return stream of JSON objects. The response is streamed by default, making it suitable for chat UIs. To disable streaming use “stream : false” in the request body.

2. Generate a chat completion

For conversational use cases we can use the following Ollama API endpoint :

POST /api/chat

Example request body :

{
"model": "qwen2.5:latest",
"messages": [
{"role": "system", "content": "You are a helpful assistant"},
{"role": "user", "content": "What is Docker?"}
],
"stream" : false
}

3. Generate Embedding

Ollama also supports embeddings for semantic search and RAG systems. To generate embedding use the following API endpoint

POST /api/embeddings

Example request body

{
"model": "all-minilm",
"prompt": "Nolowiz is awesome"
}

4. Version

This API endpoint returns the version of Ollama

GET /api/version

Conclusion

The Ollama API makes running LLMs locally simple, developer‑friendly, and practical. If you want control over your data, predictable costs, and low‑latency inference, Ollama is one of the best tools available today.

The post Ollama API: Run Large Language Models Locally with Simple APIs appeared first on NoloWiz.

Install a Model

The pull command downloads a model from the official Ollama registry. To install a model run the below command :

ollama pull <model-name>

Example :

ollama pull gemma3

Run a Model (Interactive Mode)

Starts an interactive prompt where you can chat with the model.

ollama run <model-name>

Example:

ollama run mistral

Run a Single Prompt (Non-interactive)

This command is useful for scripting or quick one-shot tasks.

ollama run <model-name> "<your prompt>"

Example:

ollama run llama3 "Write a Python function to reverse a string"

Run a Multimodal model

Some models supports are multimodal (means it supports text and image) for example gemma 3 . We can feed text/image to this model , to give an image to multimodal model run the following command:

ollama run <model> "Prompt" <image_path>

Example :

ollama run gemma3 "What's in this image" "/Users/stark/Desktop/smile.png"

Run OCR

Some models supports OCR (optical character recognition), which involves extracting text from images.LLaVA,DeepSeek OCR are examples of such models.

ollama run <OCR_model> "<Image_Path> \n OCR"
                OR
ollama run <OCR_model> "<Image_Path> \n Extract text from the image"

Example command to extract text from the image :

ollama run deepseek-ocr "C:\Users\Rupesh\Downloads\written_text.png\n OCR"

List Installed Models

Shows all local models stored on your system along with their sizes.

ollama list

Or you can run the below command

ollama ls

Show Model Details

Displays metadata like parameters, quantization type, license, etc.

ollama show <model-name>

Remove a Model

Deletes the model from your local storage.

ollama rm <model-name>

Example:

Start the Ollama Server

This runs the background server that handles API calls. Useful when integrating Ollama with:

• Python scripts
• Node.js apps
• REST API clients

ollama serve

Check Running Models

Lists currently running model sessions.

ollama ps

Stop Running Models

Stops a specific running model.

ollama stop <model-name>

Create a Custom Model

A common use case for creating a custom model in Ollama is to build a specialized version of an existing base model with a fixed system prompt, domain-specific knowledge, or predefined behavior. For example, developers often create custom models to act as coding assistants, customer-support bots, summarizers, or blog-writing agents by embedding their instructions, rules, or context directly into the Modelfile. This removes the need to repeat instructions in every prompt and ensures consistent, stable responses tailored to a specific workflow or application.

ollama create <new-model-name> -f <Modelfile path>

Here is a simple example :

First create a model file with following content, save file as cat_model

FROM gemma3:4b
SYSTEM """You are a happy cat."""

Next we can create custom model by running the below command :

ollama create catmodel -f "C:\Users\Rupesh\cat_model"

To summarize essential Ollama commands :

1. Model execution commands

• ollama run <model>
• ollama run <model> “prompt”

2. Model Information & Creation

• ollama pull <model>
• ollama show <model>
• ollama create my-model -f modelFile

3. Model Management

• ollama pull
• ollama list
• ollama rm <model>

4. Server and Process

• ollama serve
• ollama ps
• ollama stop <model>

Conclusion

Mastering these Ollama commands unlocks full control over locally running LLMs. Whether you’re building AI apps, doing offline experimentation, or running custom models, these commands will greatly enhance your productivity. Read our tutorial on LM Studio Image Generation using FastSD MCP Server

The post Essential Ollama Commands: A Complete Guide appeared first on NoloWiz.

The Problem: Why AI Forgets

Traditional AI models struggle with continual learning – when you feed them new tasks, they tend to forget earlier ones. This happens because they constantly update their core parameters, overwriting what was learned before. In neuroscience, our brains don’t work that way. Thanks to neuroplasticity, different parts of the brain adapt and update at different rates. That helps us keep old memories even as we learn new things. In contrast, most machine-learning systems treat the architecture (the “shape” of the network) separately from the optimization algorithm (how it learns). Nested Learning challenges that separation.

What Nested Learning Actually Means

Nested Learning reframes a single AI model as a network of smaller, connected learning units, each with its own role.

1. Nested Optimization Problems – Rather than one monolithic “learn everything” loop, the model is seen as multiple optimization problems running together or layered on top of each other.
2. Context Flow & Update Rates
   1. Each of these nested problems has its own “context flow”: the information it uses to learn.
   2. They also update on different time scales – some parts of the model change quickly, others more slowly. This mimics how brains consolidate memories: fast learning + slow, steady updates.
3. Unified View of Architecture + Optimization – Instead of thinking of architecture (how big or deep a network is) and optimization (how we train it) as separate, Nested Learning sees them as different levels of the same learning system.

Key Innovations

Google’s team used several clever techniques to put Nested Learning into action:

• Deep Optimizers
  • Traditional optimizers (like SGD or Adam) are reinterpreted as memory modules – they don’t just compute gradients, but store and recall information. By changing how these optimizers work (for example, using an L2 loss instead of just simple dot products), they become more robust, especially when dealing with noisy or surprising data.

• Continuum Memory Systems (CMS)
  • In standard models, you often have “short-term memory” (recent context) and “long-term memory” (what the model was pretrained on). Nested Learning expands this into a spectrum of memory modules.Each module in this continuum learns at its own pace (its own update frequency), allowing richer retention of information over different time scales.

HOPE Architecture

To prove Nested Learning actually works, Google built a prototype architecture called HOPE (Hierarchy + Experts + Smart Routing):

• It’s a self-modifying model: parts of it can change how they learn over time.
• It uses continuum memory system (CMS) blocks to handle very large contexts (i.e., long sequences of information).
• Hope can optimize not just its weights, but also its own update rules, in a loop kind of like the model “learning how to learn.”

Test results of this architecture are promising :

• It showed better performance on language modeling tasks.
• It handled long-context reasoning much better than existing models.
• In continual learning scenarios, it retained old knowledge more effectively.

The full results available in the research paper.

What This Means for the Future

• Lifelong Learning: Nested Learning is a step in building AI that truly grows over time, instead of being retrained from scratch.
• Flexible Design: Because the paradigm adds “levels” of learning (with different update speeds), future researchers can experiment with architectures that were hard to imagine before.
• Closer to Human Learning: The idea mimics how biological brains work multi-scale memory, different learning rates which could be a foundation for more adaptive and efficient AI systems.

Conclusion

Nested Learning isn’t just a tweak or a new algorithm — it’s a paradigm shift in how we think about training and structuring AI models. Instead of a flat architecture that learns all at once, it treats a model like a layered system, where different parts have their own learning rhythm. That makes it possible for AI to keep learning without discarding its past. Read about LM Studio Image Generation using FastSD MCP Server.

The post Google’s New AI Breakthrough: Nested Learning Could Change Everything appeared first on NoloWiz.

Download and install FastSD

FastSDCPU is an open-source tool that enables fast text-to-image generation with Stable Diffusion models on CPUs and Intel AI PCs, leveraging Latent Consistency Models and Adversarial Diffusion Distillation for speed. It supports desktop GUI, web UI, CLI, and can achieve sub-second image generation with Intel OpenVINO.

For this demo, we are using Windows 11. Follow the below steps to install FastSD :

• You need to install Python 3 and uv – fast package manager for Python.
• Double click install.bat (It will take some time to install, depending on your internet speed.)
• After the installation, close this command prompt window

Next, start the FastSD MCP server by running the start-mcpserver.bat file

start-mcpserver.bat

Download and Install LM Studio

LM Studio is a free, cross-platform desktop app that lets you download, run, and experiment with open-source large language models (LLMs) like LLaMA, Mistral, or Qwen entirely on your computer – offline, with no cloud or usage fees – providing a user-friendly interface, privacy, and developer APIs. Download and install LM Studio.

Download LM Studio from the official website

Next, download a Large Language Model. For this demo, I’m using Qwen2.5 -7B instruct model. Then we need to configure mcp server in the LM Studio. Click on the prompt box integrations and click install then edit mcp.json as shown below.

Then paste the below content to mcp.json

{
  "mcpServers": {
    "fastsd": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "http://127.0.0.1:8000/mcp"
      ]
    }
  }
}

Save and restart LM Studio, and we will see the FastSD MCP integration as shown below.

Now we can generate images using the FastSD MCP server and LM Studio.

Click on the external image and open the image URL in a browser.

Conclusion

In conclusion, it is easy to integrate FastSD with LM Studio, which enables it to generate images thanks to the FastSD MCP server

The post LM Studio Image Generation using FastSD MCP Server appeared first on NoloWiz.

Model Context Protocol(MCP)

Let’s first understand the Model Context Protocol (MCP). Anthropic developed the Model Context Protocol (MCP). Anthropic officially announced and open-sourced the protocol in November 2024.

The MCP protocol is designed to standardize how large language models (LLMs) and other AI systems interact with external tools, data sources, and software environments, providing a universal interface for context exchange and integration. In other words, think of MCP like a USB-C port for artificial intelligence(AI). Just like USB-C gives a common way to plug in different devices and accessories, MCP gives a common way for AI models to connect with different data sources and tools. You can read more about the MCP Specification here.

MCP follows a client-server architecture. It has following main components :

MCP Host – It is typically the application that users interact with directly, for example, Claude Desktop, Cursor, VS Code, and custom agents.

MCP Server – The MCP server is a standalone program or service that exposes specific tools, resources, and capabilities to MCP clients. (For example, FastSD MCP server)

MCP Client – The MCP client is a component that resides within the host application. It is responsible for managing connections to MCP servers. The MCP host can connect to any MCP servers.

MCP uses 3 types of transport mechanisms for communication between the server and clients.

1. stdio – Used for local MCP connections (CLI apps)
2. Server-Sent Events (SSE) – Used for remote connections.
3. Streamable HTTP – A newer transport method introduced in 2025, using a single HTTP endpoint for bidirectional messaging.

FastSD utilizes Server-Sent Events (SSE) as a transport mechanism for MCP client-server communication.

FastSD MCP server

FastSD is an optimized version of Stable Diffusion designed specifically for image generation, offering significantly faster performance compared to standard Stable Diffusion implementations. It uses OpenVINO (OpenVINO is an open-source toolkit by Intel for optimizing and deploying deep learning models. It accelerates AI inference on Intel hardware and supports various frameworks like TensorFlow, PyTorch, and ONNX. to speed up the inference on CPU, GPU, and NPU(Neural Processing Unit). To know more about FatSD and OpenVINO, read this article.

FastSD added support for the MCP Server starting from version v1.0.0-beta.200. We can use it with any MCP hosts; we will use the Claude desktop. For this demo, I’m running everything on an Intel AI PC powered by an Intel Core Ultra Processor, which integrates a CPU, GPU, and NPU. I received this device as part of the Intel Edge Innovator program. Download and install FastSD and set the “DEVICE” environment variable; this will make FastSD use the NPU.

set DEVICE=NPU

Then start-webui.bat and apply the following settings and generate an image using NPU.

• mode – LCM-OpenVINO
• OpenVINO model – rupeshs/sd15-lcm-square-openvino-int8
• Generation settings -> number of inference steps – 3 or 4

Stop/close FastSD web UI. Next, run the start-mcpserver.bat file. You will see output similar to the screenshot.

start-mcpserver.bat

We can see that the FastSD MCP server is running at the address http://127.0.0.1:8000

Claude desktop

Claude Desktop is Anthropic’s AI application for Windows and Mac that lets users interact with the Claude chatbot locally, enabling file uploads, document analysis, and chat history syncing across devices. Download and install the Claude desktop from the official website.

Start the Claude desktop and log in to your account. We need to configure Claude desktop to access FastSD MCP server to generate images.

• Open File -> Settings -> Developer – Edit config
• Add the below config(Also ensure that node.js is installed on your machine)

{
  "mcpServers": {
    "fastsd": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "http://127.0.0.1:8000/mcp"
      ]
    }
  }
}

Restart the Claude desktop(View -> reload).

FastSD supports get_system_info and generate image tools. Let’s try the system info tool, it returns the system information. Claude will ask for confirmation, click allow.

Claude desktop will display system info as shown below.

Next, we will generate an image by using the following prompt. I’ve given “share the image URL” in the prompt to display the output URL.

Create photo of a beautiful landscape,share the image url

We can open the URL in the browser by clicking it.

We can check the NPU usage by checking the Task Manager.

As we can see, NPU usage spikes in the Task Manager so Claude desktop effectively used NPU to generate an image using FastSD, thanks to OpenVINO and Intel Core Ultra processors.

Conclusion

In conclusion, Claude desktop can generate images using NPU with the FastSD MCP server and OpenVINO. Learn about How to use ComfyUI with FastSDCPU and OpenVINO.

The post Claude Desktop Image Generation using FastSD MCP Server on NPU – OpenVINO appeared first on NoloWiz.