DEV Community: Alexander Razvodovskii

Local AI Tools: Introducing LocalAI (Tool 3)

Alexander Razvodovskii — Sat, 03 Jan 2026 18:12:34 +0000

Continuing our exploration of tools for running AI models locally, the next solution to discuss is LocalAI. Unlike some desktop-focused applications, LocalAI is a full-featured AI runtime designed primarily for local and professional usage, with a strong focus on Docker-based deployment.

General Overview

LocalAI does not provide a native desktop application for Windows or macOS in the traditional sense. Instead, it is designed to be run as a service — most commonly inside a Docker container. For users who already have basic experience with Docker, LocalAI is relatively easy to install and manage.

One of its major advantages is the presence of a web-based interface, which allows users to manage models and configurations through a browser. This makes LocalAI more approachable than pure CLI-based solutions, while still remaining flexible and powerful.

Quick Start with Docker

For beginners, the simplest way to start is by running the latest LocalAI image directly via Docker. This approach requires minimal configuration and allows you to get a working system up and running quickly.

A basic example using Docker looks like this:

docker run -ti --name local-ai -p 8080:8080 localai/localai:latest

After running this command, the LocalAI web interface becomes available in the browser. From there, users can explore the system, manage models, and interact with the API.

This setup is ideal for initial testing, learning, and experimenting with local AI models.

Web Interface and Model Management

Once deployed, LocalAI provides a convenient management interface. It allows you to connect and configure different AI models depending on your hardware capabilities. Lightweight models can be used on modest systems, while more powerful machines can take advantage of larger and more complex models.

The system is flexible and adapts well to different environments, making it suitable for both casual experimentation and more serious development tasks.

Using Docker Compose

For more structured setups or long-term usage, Docker Compose is often the preferred option. It makes configuration more transparent and easier to maintain.

A minimal docker-compose.yml example for the latest version of LocalAI might look like this:

services:
  local-ai:   
    image: localai/localai:latest
    container_name: local-ai  
    ports:
      - "8080:8080"           
    tty: true                 
    stdin_open: true         
    restart: always

With this configuration, models are stored persistently on the host machine, and the service can be easily restarted or extended as part of a larger system.

CPU and GPU Configuration

LocalAI supports both CPU and GPU-based execution. Depending on your hardware configuration, you can enable GPU acceleration or add additional system resources. The project provides multiple predefined configurations optimized for different setups.

While simple models require very little tuning, using heavier models or more advanced setups does require additional knowledge about hardware resources, Docker configuration, and model optimization.

Strengths and Target Audience

What I personally like about LocalAI is its balance between simplicity and flexibility. For basic usage, there are no complicated settings or hidden pitfalls. You can start quickly and experiment with models without deep technical expertise.

At the same time, LocalAI scales well for professional usage. Developers can integrate it into workflows, automation systems, and backend services using its API. It works equally well for beginners learning about local AI and for professionals building more complex solutions.

Final Thoughts

LocalAI is a versatile and powerful tool for running AI models locally. It offers an accessible entry point for newcomers while still providing the depth required for advanced and professional use cases.

If your goal is to run AI models locally with control over data, flexibility in deployment, and strong integration potential, LocalAI is definitely a tool worth considering.

Local AI Tools: Exploring LM Studio (Tool 2)

Alexander Razvodovskii — Sat, 13 Dec 2025 22:34:47 +0000

Continuing our overview of tools for local AI usage, the next solution worth discussing is LM Studio. This is a desktop application focused primarily on ease of use and fast access to local AI models, especially for users who want to run models on their own machines without complex setup.

Simple Installation and User-Friendly Experience

LM Studio offers a very straightforward installation process. One of its key advantages is how easily AI models can be discovered, downloaded, and connected. For non-technical or less technical users, this significantly lowers the entry barrier to local AI usage.

In my opinion, LM Studio provides a more polished and intuitive user interface compared to many alternative tools. It also introduces some additional capabilities, such as running models directly inside the application and interacting with them in a chat-like environment. This makes LM Studio particularly attractive for experimentation, learning, and everyday tasks.

Using LM Studio as a Local Service

Beyond its desktop UI, LM Studio can also be used in a local server mode, which is especially interesting for developers. In this mode, LM Studio exposes an API that allows external tools and services to communicate with locally running models.

The official website includes documentation for the built-in API, making it possible to integrate LM Studio into automation and workflow tools such as n8n. In this setup, LM Studio acts as a local AI service that can be queried just like a remote API endpoint.

Limitations for Containerization and Backend Use

However, LM Studio has an important limitation from a development and infrastructure perspective. At the moment, the official documentation does not describe any way to run LM Studio inside a Docker container. This significantly narrows its use cases for server-side deployments, CI/CD pipelines, or cloud-based environments.

As a result, LM Studio is best suited for local desktop usage, rather than being part of a fully containerized or scalable backend system.

Library Integration for Developers

On the other hand, LM Studio does offer integration options in the form of libraries available via npm and pip. This means developers working with JavaScript/TypeScript or Python can integrate LM Studio into their applications more directly.

While this is a useful feature, it also highlights a limitation: developers outside the JS/TS and Python ecosystems may find fewer integration options available.

Summary and Personal Assessment

To summarize, LM Studio is a solid and well-designed application for local AI usage. It excels as a tool for everyday users thanks to its intuitive interface and simplified model management.

That said, it remains somewhat limited for advanced development scenarios and cannot yet be considered a universal solution for all AI workflows. The lack of Docker support, in particular, restricts its role in more complex or production-oriented environments.

Still, LM Studio is actively evolving. Depending on your specific tasks and requirements, it may already be a very suitable tool — and it will be interesting to see how its capabilities expand in the future.

Local AI Tools: Getting Started with Ollama (Tool 1)

Alexander Razvodovskii — Tue, 09 Dec 2025 12:15:59 +0000

Introduction

When discussing accessible local AI tools, it’s hard not to begin with one of the most popular options available today — Ollama. This tool has gained widespread recognition thanks to its simplicity, reliability, and availability across all major operating systems.

Easy Installation for Everyone

Ollama stands out because, unlike some other local AI solutions, it offers a fully functional desktop version. You can simply visit the official Ollama website, download the installer for your operating system, and launch it like any other application. Desktop versions are available for Windows, Linux, and macOS, making Ollama accessible to practically any user.

Once installed, Ollama provides access to a collection of pre-trained AI models. A complete list of these models can be found on the official website, and many of them can be downloaded directly through the installer. You are free to choose which models run locally on your machine, and Ollama also supports the option to use certain models remotely if needed.

I won’t go into the installation process here — it’s straightforward and follows the standard steps for your operating system. The only additional requirement is to complete a simple registration so the desktop app can connect with the Ollama service.

Please note that Ollama has a paid subscription. If you're focusing on cloud-based use, you may need to upgrade your subscription.

Beyond Desktop: Running Ollama in a Container

Although the desktop version is the easiest entry point, Ollama is not limited to that. The tool can also be deployed in a Docker container, which is especially convenient for developers and users who want more control over their environment or plan to integrate Ollama into automated workflows.

The documentation provides clear instructions for installing and running the Docker version using a single command. Once deployed, Ollama runs as a local server accessible from your machine.

docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

docker exec -it ollama ollama run llama3.2

http://localhost:11434/

Ollama is running

However, unlike some other tools we’ll explore later in this series, Ollama does not include a web interface when running inside a container. Interaction with the system is performed exclusively through the API, which is thoroughly documented on the website. The API allows you to:

List available models
Submit a prompt
Receive responses programmatically

It should be noted here that the model's response is sent in stream form.

async function askModel() {
  const response = await fetch("http://localhost:11434/api/generate", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      model: "llama3.2",
      prompt: "Who are you?"
    })
  });

  const reader = response.body.getReader();
  const decoder = new TextDecoder("utf-8");

  // output a stream response
  while (true) {
    const { done, value } = await reader.read();
    if (done) break;
    console.log(decoder.decode(value));
  }
}

askModel();

{
    "model": "llama3.2",
    "created_at": "2025-12-09T10:20:54.622934272Z",
    "response": "I",
    "done": false
}{
    "model": "llama3.2",
    "created_at": "2025-12-09T10:20:54.761152451Z",
    "response": "'m",
    "done": false
}
...

Communication happens through standard POST requests to the local server, and the API format will feel intuitive to anyone with basic experience integrating services.

Installing Ollama Through a Dockerfile

To install Ollama inside a container, we begin by creating a Dockerfile. This file defines how the container will be built, including downloading and installing Ollama.

Additionally, for convenience, we can preload a specific AI model during build time. This saves time later and ensures that the required model is already available when the container starts.

Here’s an example structure:

Dockerfile
entrypoint.sh (the bash script that pulls the model)

Dockerfile

FROM ollama/ollama:latest
COPY entrypoint.sh /entrypoint.sh
RUN chmod +x /entrypoint.sh
EXPOSE 11434
ENTRYPOINT ["/entrypoint.sh"]

entrypoint.sh

#!/bin/bash
ollama serve &
sleep 3
ollama pull llama3.1
wait

This allows us to include Ollama as a component of any project — web service, automation pipeline, or local development setup — by simply running:

docker build -t my-ollama .
docker run -p 11434:11434 my-ollama

With this setup, Ollama becomes a plug-and-play module that can be easily distributed, reused, and integrated into more complex systems.

Integrations

The documentation also includes examples for connecting Ollama to modern development and workflow tools such as n8n, Visual Studio Code, JetBrains IDEs, Codex, and others — making it easier to fit Ollama into broader automation or development pipelines.

Strengths and Limitations

In my view, the main advantage of Ollama is its simplicity. It’s easy to install, widely available, and accessible even to users who are not deeply technical. For those who want to experiment with AI models on their own machine without complicated setup, it’s an excellent starting point.

That said, as we will explore in the next articles, Ollama is not always the most efficient or flexible solution — especially for developers who need deeper customization, advanced configuration, or who plan to integrate AI services heavily into complex workflows. In such scenarios, alternative tools may provide more performance or better integration capabilities.

Artificial Intelligence in Everyday Work: Why Local Models Matter (Introduction)

Alexander Razvodovskii — Mon, 08 Dec 2025 10:38:34 +0000

Artificial intelligence is rapidly expanding its presence in our daily and professional workflows. More and more tasks rely on AI-powered solutions, and a growing number of models are being integrated into both everyday consumer applications and complex business processes. As a result, the demand for AI models delivered as services continues to grow.

At the same time, concerns about data protection are becoming increasingly important. Many users and organizations prefer to keep their information private rather than send sensitive data to large cloud-based AI providers. This naturally raises an important question: How can we use AI models directly on our personal computers or laptops, without depending on external cloud services?

Fortunately, the ecosystem around local AI is evolving rapidly. A number of solutions already exist that make running models locally not only possible, but in many cases surprisingly simple. These tools allow users to maintain full control over their data while still benefiting from powerful AI capabilities. As demand increases, the market continues to offer more accessible, efficient, and user-friendly options.

In this series of articles, I will explore the most available approaches for running AI models locally and discuss what opportunities and advantages localized AI systems provide. We’ll look at the different tools, compare their capabilities, and walk through the process of implementing such a system on your personal machine. We will also explore how to integrate local AI tools into broader workflows and automation pipelines.

Additionally, we will dive into key practical topics:

How to choose the right AI model for your needs
How to install and run models on your local computer
How various tools and runtimes differ in performance and speed
How to embed AI capabilities into your daily work processes

The goal of this series is to give a clear, beginner-friendly overview of the current local AI landscape and help you understand how to bring powerful AI tools directly to your own device.

Developing Wordpress projects with Docker. Part 1. Create new project.

Alexander Razvodovskii — Sat, 13 Sep 2025 16:12:50 +0000

Introduction.

In this series of articles we will talk about deploying WordPress projects on a local machine and then transferring projects to the server, including various aspects related to deploying new and existing projects, backups, transferring existing projects, database access, etc.

PART 1. Create new project.

Wordpress has been around for a long time, it has already celebrated its 20th anniversary. The project was so successful that today a huge number of sites have been created on it. There are probably developers who have been creating various projects on Wordpress for all these twenty years. In my practice, Wordpress has found application both as a ready-to-deploy CMS and as a base for creating non-trivial projects, such as a marketplace for wholesale supplies of agricultural products.
Previously, I used LAMP to deploy and develop Wordpress projects, and later I simplified my development using ready-made local servers, such as OpenServer. Modern development has provided new tools that allow you to quickly and easily deploy projects and install them on a server without wasting time. In my current work, I have transferred development to Docker, and I want to introduce readers of my blog to working with it.

In the first part, we will get acquainted with the process of creating a Wordpress project from scratch.

I hope that my reader already knows what Docker is. If you don't have a local version installed yet, you can download it from the official Docker.com website

Project Structure

Let's start. Now you can create a folder for your project. Open the folder and create below structure inside.

We have 2 empty folders and 2 files
The folder mysql is for your database. The folder wordpress is for Wordpress files which you will edit later. Right now you do not need copy anything into the folders.
So, let's focus to the files.

Files

The file .env contains default settings details for your project. Usually we do not copy the file into repositories or share this file. This file is for your local system only. However, it is important to create the file anywhere you install the project. Change DB name, User and Password with your own data.

.env

# MySQL 
MYSQL_ROOT_PASSWORD=your_secure_root_password
MYSQL_DATABASE=wordpress_db
MYSQL_USER=wordpress_user
MYSQL_PASSWORD=your_secure_password

# WordPress settings
WORDPRESS_DEBUG=0

The file docker-compose.yml is our main file. It contains detailed instructions for creating our project, parts, and relations.

docker-compose.yml

version: '3.8'

services:
  # MySQL
  mysql:
    image: mysql:8.0
    container_name: wordpress_mysql
    restart: unless-stopped
    env_file: .env
    environment:
      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}
      MYSQL_DATABASE: ${MYSQL_DATABASE}
      MYSQL_USER: ${MYSQL_USER}
      MYSQL_PASSWORD: ${MYSQL_PASSWORD}
    volumes:
      - ./mysql/data:/var/lib/mysql
      - ./mysql/init.sql:/docker-entrypoint-initdb.d/init.sql
    networks:
      - wordpress_network
    command: --default-authentication-plugin=mysql_native_password

  # WordPress
  wordpress:
    image: wordpress:latest
    container_name: wordpress_app
    restart: unless-stopped
    env_file: .env
    environment:
      WORDPRESS_DB_HOST: mysql:3306
      WORDPRESS_DB_USER: ${MYSQL_USER}
      WORDPRESS_DB_PASSWORD: ${MYSQL_PASSWORD}
      WORDPRESS_DB_NAME: ${MYSQL_DATABASE}
    volumes:
      - ./wordpress/wp-content:/var/www/html/wp-content
    ports:
      - "8000:80"
    depends_on:
      - mysql
    networks:
      - wordpress_network

  # phpMyAdmin
  phpmyadmin:
    image: phpmyadmin:latest
    container_name: wordpress_phpmyadmin
    restart: unless-stopped
    environment:
      PMA_HOST: mysql
      PMA_PORT: 3306
      PMA_ARBITRARY: 0
    ports:
      - "8080:80"
    depends_on:
      - mysql
    networks:
      - wordpress_network

networks:
  wordpress_network:
    driver: bridge

Let's focus on some parts of the file.
As you see the file has 3 big blocks (Services):

MySQL
Wordpress
phpMyAdmin

In first part Docker create a DB for our project. It takes settings from our .env file and put them as a default settings. Later, after building the project, you will find your DB files in the folder mysql.
Next part is our Wordpress project. Docker doesn't need having Wordpress files. It will download the files from Docker's library during building project. All files will be placed in the folder wordpress. These files are for editing, the Docker placed in the folder the files from wp-content folder only. So a developer can be sure the core of Wordpress is not editable and he can destroy nothing.
The last part phpMyAdmin is not required. I added it for easier way to access to DB. You can remove it and use any other tool for edit MySQL.

Let's pay attention to the tail - networks. This part is for connecting all parts to each others.

Run Containers

Now our project is ready to run. Before building the project please check, whether the Docker has been run on your PC.
Now open the folder with docker-compose.yml in terminal (cmd, bash) and run below command:

docker-compose up -d

During few minutes Docker will build the project and you can run it in your browser by following URLs:

Wordpress Project

http://localhost:8000/

PhpMyAdmin

http://localhost:8080/

Open the folder wordpress in your code editor. Now you can continue developing you website with fun.

Phishing campaign for tricking Booking.com's users and sharing malware.

Alexander Razvodovskii — Sat, 16 Aug 2025 14:25:14 +0000

Researchers have noticed a new phishing strategy used by threat actors. This strategy is seen around links sent by threat actors under the guise of links to the Booking.com website. However, users should be careful, as it is possible that the strategy could be used in other phishing campaigns.
First spotted by security specialist JAMESWT, the attack was described in his blog - on August 12, he reported about it. Also, he published the details on the online platform Malware bazaar.
The strategy base is in using of the letter "ん" (Unicode U+3093) in a fishing address. The letter is invisible to the superficial eye and is associated with the slash sign ("/"). In some fonts it looks like the Latin letter "/n" or "/~".
In his post on the X network, JAMESWT gave an example of a detected spoofed address

At the same time, the letter sent by the attackers does not contain the specified symbol.

And also he provided a link to a demonstration of the phishing site.

Victims who click on the link are ultimately redirected to the link that installed the malware.
To avoid becoming a victim of phishing, users are advised to check the actual domain at the right end of the address before the first slash symbol ("/") - this is the real registered domain.

Sources:
[1] JAMESWT - https://x.com/JAMESWT_WT/status/1955060839569870991
[2] BleepingComputer https://www.bleepingcomputer.com/news/security/bookingcom-phishing-campaign-uses-sneaky-character-to-trick-you/