Forem: IT Solutions Pro

Build a "Military-Grade" Network Scanner in Python (Scapy Tutorial)

IT Solutions Pro — Tue, 03 Feb 2026 18:35:38 +0000

In the world of cybersecurity, information is power. Before an attack happens, there is a phase of observation—watching, listening, and mapping out the network.

Imagine knowing exactly every device connected to your Wi-Fi right now. Your neighbor’s phone, your smart TV, or maybe even an intruder lurking on your network.

Most people rely on pre-made tools like Nmap. But today, we are going to build our own.

In this tutorial, we will write a Python script that reverse-engineers the ARP (Address Resolution Protocol) to discover devices on any network.

Prerequisites

Before we write code, we need to handle the "Layer 2" drivers. Python cannot speak directly to the network card without help.

1. For Windows Users (Critical)

You must install Npcap.

Go to npcap.com.
Important: During installation, check the box "Install Npcap in WinPcap API-compatible Mode".

2. Install Scapy

We will use scapy, a powerful packet manipulation library.
Open your terminal/command prompt and run:

pip install scapy

The Code Construction
We will build this in 3 phases using a single file: scanner.py.

Phase 1: Handling Arguments
We don't want to hard-code the IP. We want to pass it via the command line (e.g., -t 10.0.0.1/24).

import scapy.all as scapy
import argparse
import time

def get_arguments():
    parser = argparse.ArgumentParser()
    parser.add_argument("-t", "--target", dest="target", help="Target IP / IP range.")
    options = parser.parse_args()

    # Smart Logic: If user forgets the IP, default to a test range
    if not options.target:
        print("[-] No target specified. Defaulting to 192.168.1.1/24 for demo.")
        return "192.168.1.1/24"

    return options.target

Phase 2: The Scanner Engine
This is where the magic happens. We create an Ethernet frame destined for ff:ff:ff:ff:ff:ff (Broadcast), ensuring every device hears us.

def scan(ip):
    print(f"\n[+] Starting Scan on {ip}...\n")
    print("-" * 50)
    print("IP Address\t\tMAC Address")
    print("-" * 50)

    # 1. Create ARP Request
    arp_request = scapy.ARP(pdst=ip)

    # 2. Create Broadcast Frame
    broadcast = scapy.Ether(dst="ff:ff:ff:ff:ff:ff")

    # 3. Combine Frame
    arp_request_broadcast = broadcast/arp_request

    # 4. Send & Receive
    # verbose=False keeps the terminal clean
    answered_list = scapy.srp(arp_request_broadcast, timeout=1, verbose=False)[0]

    clients_list = []

    for element in answered_list:
        client_dict = {"ip": element[1].psrc, "mac": element[1].hwsrc}
        clients_list.append(client_dict)

        # visual effect: print immediately
        print(f"{element[1].psrc}\t\t{element[1].hwsrc}")
        time.sleep(0.1) # Cinematic delay

    return clients_list

The Full Source Code
Here is the complete script. Copy this into a file named scanner.py.

Python

import scapy.all as scapy
import argparse
import time

def get_arguments():
    parser = argparse.ArgumentParser()
    parser.add_argument("-t", "--target", dest="target", help="Target IP / IP range.")
    options = parser.parse_args()
    if not options.target:
        print("[-] Please specify a target IP range. Use --help for more info.")
        # Default to local range if not provided
        return "192.168.1.1/24" 
    return options.target

def scan(ip):
    print(f"\n[+] Starting Scan on {ip}...\n")
    print("-" * 50)
    print("IP Address\t\tMAC Address")
    print("-" * 50)

    arp_request = scapy.ARP(pdst=ip)
    broadcast = scapy.Ether(dst="ff:ff:ff:ff:ff:ff")
    arp_request_broadcast = broadcast/arp_request

    # Send packet and wait for response
    answered_list = scapy.srp(arp_request_broadcast, timeout=1, verbose=False)[0]

    clients_list = []
    for element in answered_list:
        client_dict = {"ip": element[1].psrc, "mac": element[1].hwsrc}
        clients_list.append(client_dict)
        print(f"{element[1].psrc}\t\t{element[1].hwsrc}")
        time.sleep(0.1) # Added delay for visual effect

    return clients_list

def print_result(results_list):
    print("-" * 50)
    print(f"[+] Scan Complete. Found {len(results_list)} devices.")

if __name__ == "__main__":
    target_ip = get_arguments()
    scan_result = scan(target_ip)
    print_result(scan_result)

Conclusion
You just built a professional network reconnaissance tool in under 60 lines of code. This is the foundation of network security.

If you enjoyed this, I have a full video breakdown explaining every single line of code below.

📺 Watch the Masterclass

For more IT Masterclasses, subscribe to: @it_solutions_pro

Build a Self-Hosted AI Server (n8n + Docker + OpenAI)

IT Solutions Pro — Fri, 30 Jan 2026 17:45:17 +0000

If you are serious about automation in 2026, you have two choices: Pay monthly fees for services like Zapier, or become the architect of your own infrastructure.

Today, we choose option two.

We are building a self-hosted AI server that monitors inputs, analyzes them with GPT-4, and sends intelligent alerts directly to Telegram—all running locally via Docker.

This isn't just a toy project; this is an enterprise-grade solution that you can run on a local machine, a Raspberry Pi, or a cloud VPS for pennies.

Why Self-Host?

Privacy: Your data stays on your machine.
Cost: No more "pay per task" limits like Zapier.
Power: You get full control over the AI logic and database.

Prerequisites

Docker Desktop installed.
VS Code text editor.
An OpenAI API Key.

Step 1: Secure Configuration (.env)

First, we need to set up our environment variables. This keeps our passwords safe and out of the main code.
Create a file named .env:

.env file configuration

POSTGRES_USER=n8n
POSTGRES_PASSWORD=mysecretpassword
POSTGRES_DB=n8n
N8N_ENCRYPTION_KEY=supersecretkey123
N8N_HOST=localhost
N8N_PORT=5678
GENERIC_TIMEZONE=America/New_York

Step 2: The Architecture (docker-compose.yml)
We are using Docker Compose to spin up two containers:

PostgreSQL: A robust database to store workflow history.

n8n: The workflow automation tool itself.

Create a file named docker-compose.yml:

YAML

version: '3.8'

services:
  postgres:
    image: postgres:16-alpine
    restart: always
    environment:
      - POSTGRES_USER=${POSTGRES_USER}
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
      - POSTGRES_DB=${POSTGRES_DB}
    volumes:
      - postgres_data:/var/lib/postgresql/data

  n8n:
    image: n8nio/n8n:latest
    restart: always
    ports:
      - "5678:5678"
    environment:
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - DB_POSTGRESDB_PORT=5432
      - DB_POSTGRESDB_DATABASE=${POSTGRES_DB}
      - DB_POSTGRESDB_USER=${POSTGRES_USER}
      - DB_POSTGRESDB_PASSWORD=${POSTGRES_PASSWORD}
      - N8N_ENCRYPTION_KEY=${N8N_ENCRYPTION_KEY}
      - N8N_HOST=${N8N_HOST}
    links:
      - postgres
    volumes:
      - n8n_data:/home/node/.n8n
    depends_on:
      - postgres

volumes:
  postgres_data:
  n8n_data:

How to Run It
Open your terminal in the same folder and run:


docker compose up -d

Then visit http://localhost:5678 in your browser.

Step 3: Programming the AI Agent
To make this system smart, we need to give the AI specific instructions. When setting up the AI Agent Node in n8n, use this System Prompt to enforce "Structured Output" (JSON):

Plaintext
You are a Senior IT Support Automation Agent.
Your job is to analyze incoming text and categorize it.

RULES:

If the text contains words like "crash", "down", "urgent", or "fire", categorize as "HIGH_PRIORITY".
Otherwise, categorize as "LOW_PRIORITY".

OUTPUT FORMAT (JSON ONLY):

{ "category": "HIGH_PRIORITY" | "LOW_PRIORITY", "suggested_reply": "Write a short, professional response to the user here." }
Step 4: Connecting Telegram
To receive alerts on your phone:

Search for @botfather on Telegram.

Type /newbot to get your API Token.

Search for @userinfobot to get your personal Chat ID.

Use these credentials in the Telegram Node in n8n.

Conclusion
You have just built a system that would cost enterprise companies thousands of dollars, and you did it for free on your own hardware. That is the power of open-source IT.

In the next tutorial, we will secure this server with SSL and a custom domain.

Happy Automating!

📺 Watch the Full Masterclass

If you prefer text, check out the channel here: @it_solutions_pro

Build a "Stateful" AI Chatbot with Python & OpenAI

IT Solutions Pro — Wed, 28 Jan 2026 20:40:32 +0000

Most beginners make a critical mistake when working with the OpenAI API: they assume the AI remembers them.

By default, Large Language Models (LLMs) are "Stateless". This means if you say "My name is Shakar," and then ask "What is my name?" in the next request, the API will have no idea who you are.

In this tutorial, we are going to fix that. We will build a Stateful chatbot in Python that maintains conversation history, handles errors gracefully, and runs locally in your terminal.

📺 Watch the Full Masterclass

If you prefer text, check out the channel here: IT Solutions Pro

import os
from dotenv import load_dotenv
from openai import OpenAI

# 1. Load environment variables securely
load_dotenv()

# 2. Initialize the Client
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

print("--- AI Chatbot Initialized (Type 'quit' to exit) ---")

# 3. Setup Memory (System Context)
# This sets the behavior of the AI
messages = [
    {"role": "system", "content": "You are a helpful, friendly IT Assistant."},
]

# 4. The Main Loop
while True:
    try:
        user_input = input("\nYou: ")

        # Exit Condition
        if user_input.lower() in ['quit', 'exit']:
            print("Shutting down...")
            break

        # STEP A: Add User Input to Memory
        messages.append({"role": "user", "content": user_input})

        # STEP B: Send the WHOLE history to the API
        response = client.chat.completions.create(
            model="gpt-4o", # You can use "gpt-3.5-turbo" to save cost
            messages=messages,
            temperature=0.7
        )

        # STEP C: Extract Answer & Add to Memory
        ai_response = response.choices[0].message.content

        # Crucial Step: Save the AI's own words back to the list
        messages.append({"role": "assistant", "content": ai_response})

        print(f"AI: {ai_response}")

    except Exception as e:
        print(f"An error occurred: {e}")
        break

Build a Military-Grade SOC for $0 (Wazuh + Docker + Python)

IT Solutions Pro — Tue, 27 Jan 2026 16:29:41 +0000

**STOP paying $5,000/month for enterprise security tools like Splunk or Datadog just to monitor your home lab or small business server.

You can build a Military-Grade Security Operations Center (SOC) entirely for free using Open Source tools.

In this masterclass, I’ll show you how to deploy Wazuh (The Open Source SIEM) using Docker, and then we will write a custom Python Attack Bot to test our defenses in real-time.
**

📺 Watch the Full Masterclass

🛠️ What We Build in This Video:

The Architecture: Setting up the Wazuh Manager (The Brain) and Agents (The Eyes).
Docker Deployment: Getting the stack up in under 3 minutes.
The Attack: Writing a Python script (audit_tool.py) to simulate a brute-force attack.
The Defense: Configuring a Custom XML Rule to detect the pattern and auto-ban the IP.

### 👨‍💻 The Code

Don't want to type everything from the video? Here is the source code for the tools we built.

1. The Python Attack Bot (`audit_tool.py`)

Use this script to simulate an attack on your own server (Do NOT use this on servers you don't own).

python

import paramiko
import socket
import time

# CHANGE THIS to your local server IP
TARGET_IP = "192.168.1.XX" 
USER = "root"

print(f"[*] Starting Audit Tool targeting {TARGET_IP}...")

while True:
    password = input("Enter Password to Test: ")

    try:
        client = paramiko.SSHClient()
        client.set_missing_host_key_policy(paramiko.AutoAddPolicy())

        # Attempt Connection
        client.connect(TARGET_IP, username=USER, password=password, timeout=3)
        print("[+] SUCCESS: Password Found!")
        client.close()
        break

    except paramiko.AuthenticationException:
        print("[-] Auth Failed: Wrong Credentials.")
    except socket.error:
        print("[!!!] CONNECTION REFUSED: Server blocked us! (Active Response Worked)")
        break
    except Exception as e:
        print(f"[!] Error: {e}")

<rule id="100003" level="10" frequency="15" timeframe="10">
  <if_matched_sid>60137</if_matched_sid>
  <description>Critical: Massive Logoff Flood Detected (Possible Brute Force)</description>
</rule>

Build Your Own Private AI Station: Llama + Open WebUI with Docker

IT Solutions Pro — Fri, 16 Jan 2026 12:39:40 +0000

📄 Content (Markdown):
Privacy in AI is no longer a luxury; it’s a necessity. If you are tired of sending your sensitive data to cloud-based LLMs and paying monthly subscriptions, it's time to host your own.

In this guide, I will show you how to deploy Llama 3.1 using Ollama and Open WebUI inside Docker. This setup gives you a ChatGPT-like experience running 100% locally on your hardware.

Why Llama 3.1 + Open WebUI?
Complete Privacy: Your prompts never leave your local network.

Rich UI: Open WebUI provides a professional interface with Markdown support, image generation integration, and document RAG.

Performance: Llama 3.1 (8B) is highly optimized for consumer-grade GPUs like the RTX 30-series or 40-series.

🛠 The Stack
Ollama: The engine that runs the model.

Open WebUI: The professional frontend.

Docker: To keep the environment clean and isolated.

Quick Deployment (Docker Compose)
Create a docker-compose.yml file and paste this configuration:

YAML

services:
  ollama:
    volumes:
      - ./ollama:/root/.ollama
    container_name: ollama
    pull_policy: always
    tty: true
    restart: unless-stopped
    image: ollama/ollama:latest

  open-webui:
    build:
      context: .
      args:
        - UID=1000
        - GID=1000
    image: ghcr.io/open-webui/open-webui:main
    container_name: open-webui
    volumes:
      - ./open-webui:/app/backend/data
    depends_on:
      - ollama
    ports:
      - 3000:8080
    environment:
      - 'OLLAMA_BASE_URL=http://ollama:11434'
    extra_hosts:
      - "host.docker.internal:host-gateway"
    restart: unless-stopped```



🚀 How to Run
Install Docker and Docker Compose.

Run docker-compose up -d.

Access the UI at http://localhost:3000.

Download the model inside the UI by typing llama3.1.

🎥 Full Step-by-Step Masterclass
If you want to see the full installation, including GPU optimization settings, persistent storage configuration, and a tour of the best features, I have recorded a detailed 15-minute Masterclass.

Watch the full tutorial on IT Solutions Pro: 

  
  



Conclusion
Running Llama 3.1 locally is a game-changer for developers and IT professionals. It’s fast, secure, and free.

If you encounter any issues with the Docker configuration, feel free to drop a comment below or on my YouTube channel!

#ai #selfhosted #docker #llama3 #opensource``

Forem: IT Solutions Pro

Build a "Military-Grade" Network Scanner in Python (Scapy Tutorial)

Prerequisites

1. For Windows Users (Critical)

2. Install Scapy

Build a Self-Hosted AI Server (n8n + Docker + OpenAI)

Why Self-Host?

Prerequisites

Step 1: Secure Configuration (.env)

.env file configuration

Build a "Stateful" AI Chatbot with Python & OpenAI

📺 Watch the Full Masterclass

Build a Military-Grade SOC for $0 (Wazuh + Docker + Python)

📺 Watch the Full Masterclass

🛠️ What We Build in This Video:

1. The Python Attack Bot (audit_tool.py)

Build Your Own Private AI Station: Llama + Open WebUI with Docker

1. The Python Attack Bot (`audit_tool.py`)