DEV Community: Adetola Jesulayomi

How to Build a Web Monitoring Workflow with Python, n8n & Docker using Telegram Alerts

Adetola Jesulayomi — Mon, 29 Sep 2025 13:18:08 +0000

In this guide, you’ll build a monitoring workflow using FastAPI (Python) for checks, n8n as the orchestration/automation, and Telegram for immediate alerts.

Here's what you'll build

A Python microservice (FastAPI) that performs endpoint checks /check and exposes /health.
n8n workflow that calls the Python service on a schedule, filters results, and sends well-formatted Telegram alerts.
Docker Compose deployment; everything runs in containers on the same network.

Prerequisites & Tools

Python (version python:3.10-slim)
Docker & Docker Compose
n8n (self-hosted)
Telegram Bot / Chat ID
Basic knowledge of HTTP, JSON

What is n8n?

N8N is a no-code workflow automation tool that allows you to connect to different apps and services easily. With n8n, you can connect different apps using nodes that represent a specific action, such as connecting to an API, sending an email, or scraping a website. Typically, an n8n workflow includes

Trigger node: Starts your workflow (e.g, Gmail trigger, webhook, etc).
Action nodes: Perform actions in your workflow and define specific applications (e.g, organizing data, sending messages, calling APIs, etc).

n8n's documentation

Setting up the project

1. Project Layout

Files you'd need to create.

monitoring/
├── python_service/
│   ├── app.py
│   ├── monitor.py
│   ├── requirements.txt
│   └── Dockerfile
├── n8n/
│   └── workflows/telegram_monitor.json
├── docker-compose.yml
└── .env

2. Python Microservice (FastAPI)

Create python_service/app.py:

from fastapi import FastAPI
from pydantic import BaseModel
import time
from typing import List
from monitor import perform_checks, CheckInput, CheckResult, load_state, save_state

app = FastAPI(title="Monitoring Service")

class CheckInputList(BaseModel):
    endpoints: List[CheckInput]

class CheckResultList(BaseModel):
    results: List[CheckResult]

@app.on_event("startup")
def startup_event():
    # load persistent state into monitor
    load_state()

@app.post("/check", response_model=CheckResultList)
def check_all(ci: CheckInputList):
    results = perform_checks(ci.endpoints)
    save_state()
    return {"results": results}

@app.get("/health")
def health():
    return {"status": "ok", "time": time.time()}

Create python_service/monitor.py:

import os
import json
import time
from typing import List, Optional
import httpx
from pydantic import BaseModel

STATE_PATH = os.getenv("STATE_PATH", "/data/state.json")

class CheckInput(BaseModel):
    name: Optional[str]
    url: str
    expect_text: Optional[str] = None

class CheckResult(BaseModel):
    name: Optional[str]
    url: str
    ok: bool
    status_code: Optional[int] = None
    latency_ms: Optional[int] = None
    error: Optional[str] = None
    transitioned: Optional[str] = None  # "up_to_down", "down_to_up", or None
    time: float = time.time()

_state = {}  # url -> {"ok": bool}

def load_state():
    global _state
    try:
        with open(STATE_PATH, "r") as f:
            _state = json.load(f)
    except Exception:
        _state = {}

def save_state():
    global _state
    try:
        os.makedirs(os.path.dirname(STATE_PATH), exist_ok=True)
        with open(STATE_PATH, "w") as f:
            json.dump(_state, f)
    except Exception as e:
        print("Failed to save state:", e)

def perform_check(ci: CheckInput) -> CheckResult:
    start = time.monotonic()
    resp = None
    try:
        resp = httpx.get(ci.url, timeout=10)
        latency = int((time.monotonic() - start) * 1000)
        ok = (resp.status_code == 200) and (ci.expect_text is None or ci.expect_text in resp.text)
        err = None
    except Exception as e:
        ok = False
        latency = None
        err = str(e)

    prev = _state.get(ci.url, {"ok": True})
    transitioned = None
    if ok and not prev.get("ok", True):
        transitioned = "down_to_up"
    elif not ok and prev.get("ok", True):
        transitioned = "up_to_down"

    _state[ci.url] = {"ok": ok}

    return CheckResult(
        name=ci.name,
        url=ci.url,
        ok=ok,
        status_code=(resp.status_code if resp else None),
        latency_ms=latency,
        error=err,
        transitioned=transitioned,
        time=time.time(),
    )

def perform_checks(endpoints: List[CheckInput]) -> List[CheckResult]:
    results = []
    for ep in endpoints:
        results.append(perform_check(ep))
    return results

requirements.txt:

fastapi
uvicorn[standard]
httpx
pydantic

Dockerfile:

FROM python:3.10-slim

WORKDIR /app
COPY requirements.txt ./
RUN pip install --no-cache-dir -r requirements.txt

COPY app.py monitor.py ./

ENV STATE_PATH=/data/state.json
RUN mkdir -p /data

EXPOSE 8000
CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

3. The docker-compose.yml

Next, we'll be creating the docker-compose.yml file:

version: "3.8"
services:
  n8n:
    image: n8nio/n8n:latest
    environment:
      - DB_SQLITE_VACUUM_ON_STARTUP=true
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=${N8N_USER}
      - N8N_BASIC_AUTH_PASSWORD=${N8N_PASSWORD}
      - WEBHOOK_URL=${WEBHOOK_URL}
    ports:
      - "5679:5678"
    depends_on:
      - python
    networks:
      - monitor_net

  python:
    build:
      context: ./python_service
    volumes:
      - python_state:/data
    networks:
      - monitor_net

networks:
  monitor_net:
    driver: bridge

volumes:
  python_state:

Also, let's create config.json

{
    "auths": {
        "https://index.docker.io/v1/": {},
        "https://index.docker.io/v1/access-token": {},
        "https://index.docker.io/v1/refresh-token": {}
    },
    "credsStore": "wincred",
    "currentContext": "desktop-linux"
}

.env (example):

N8N_USER=monitorapp
N8N_PASSWORD='Eas8Y!P@@sw@rd'
WEBHOOK_URL=http://localhost:5678
N8N_PORT=5679   # optional host port for n8n

Finally, create telegram_monitor.json:

{
  "nodes": [
    {
      "parameters": {
        "interval": 1,
        "unit": "minutes"
      },
      "name": "Schedule Trigger",
      "type": "n8n-nodes-base.scheduleTrigger",
      "typeVersion": 1,
      "position": [250, 300]
    },
    {
      "parameters": {
        "url": "http://python:8000/check",
        "method": "POST",
        "jsonParameters": true,
        "bodyParametersJson": "={\"endpoints\": [ {\"name\":\"prod\",\"url\":\"https://www.invalid.domain\",\"expect_text\":\"OK\"} ] }"
      },
      "name": "Python Check",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 2,
      "position": [450, 300]
    },
    {
      "parameters": {
        "value": "={{ $node[\"Python Check\"].json[\"results\"] }}",
        "options": {
          "type": "splitInBatches",
          "batchSize": 1
        }
      },
      "name": "Split Results",
      "type": "n8n-nodes-base.splitInBatches",
      "typeVersion": 1,
      "position": [650, 300]
    },
    {
      "parameters": {
        "rules": [
          {
            "value1": "={{ $json[\"transitioned\"] }}",
            "operation": "isNotEmpty"
          }
        ]
      },
      "name": "Filter Transitions",
      "type": "n8n-nodes-base.if",
      "typeVersion": 1,
      "position": [850, 300]
    },
    {
      "parameters": {
        "chatId": "98765432",
        "text": "={{ $json[\"name\"] || $json[\"url\"] }} changed status: {{ $json[\"transitioned\"] }}. StatusCode={{ $json[\"status_code\"] }}, Latency={{ $json[\"latency_ms\"] }}ms, Error={{ $json[\"error\"] }}",
        "parseMode": "HTML"
      },
      "name": "Telegram Alert",
      "type": "n8n-nodes-base.telegram",
      "typeVersion": 1,
      "position": [1050, 300]
    }
  ],
  "connections": {
    "Schedule Trigger": {
      "main": [
        [
          {
            "node": "Python Check",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Python Check": {
      "main": [
        [
          {
            "node": "Split Results",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Split Results": {
      "main": [
        [
          {
            "node": "Filter Transitions",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Filter Transitions": {
      "main": [
        [
          {
            "node": "Telegram Alert",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  }
}

4. Building the n8n workflow

We can choose to build the workflow manually or import the JSON file. Since we'll be running n8n locally rather than cloud, n8n recommends using Docker for most self-hosting needs. You can also use n8n in Docker with Docker Compose.

Starting n8n

Before proceeding, download and install Docker (available on Mac, Windows and Linux)

You can follow along with n8n's video guide here:

From your terminal, run the following commands, replacing the placeholders with your timezone:

docker volume create n8n_data

docker run -it --rm \
 --name n8n \
 -p 5678:5678 \
 -e GENERIC_TIMEZONE="<YOUR_TIMEZONE>" \
 -e TZ="<YOUR_TIMEZONE>" \
 -e N8N_ENFORCE_SETTINGS_FILE_PERMISSIONS=true \
 -e N8N_RUNNERS_ENABLED=true \
 -v n8n_data:/home/node/.n8n \
 docker.n8n.io/n8nio/n8n

Once it's running, you can access n8n at http://localhost:5678.

Building the n8n & Telegram workflow

1. Create a Telegram Bot

Open Telegram, search for @botfather (Telegram’s tool for creating and managing bots).
Use the /newbot command to create a new bot (pick a name and username ending with bot).
BotFather will give you an API token (save this to ass in your n8n credentials).

2. Get your Chat ID

In Telegram, search for @get_id_bot or @myidbot and start a chat with it.
Send /getid to it.
It will respond to you with your chat’s ID.

3. Start n8n with Docker

Make sure n8n is running in Docker
Open htttp://localhost:5678
Log in with the N8N_USER/N8N_PASSWORD you set in .env

4. Add Telegram Credentials in n8n

In n8n, go to Credentials and create new.
Choose Telegram API
Paste the BotFather token
Name the credential anything you like and save.

5. Import the workflow JSON

In n8n, click Create Workflow, and Import from File
Select monitoring/n8n/workflows/telegram_monitor.json
It will show your workflow with nodes: Schedule Trigger, Python Check, Split Results, Filter Transitions and Telegram Alert

6. Configure the Telegram Node

Open the Telegram Alert node
In Credentials, select the Telegram bot credential you created
In Chat ID, replace Chat ID with the number you got from @get_id_bot or @myidbot
Change Text to:

🔔 Status Update
Service: {{$json["results"] ? ($json["results"][0]["name"] || $json["results"][0]["url"]) : ($json["name"] || $json["url"] || "Unknown")}}
Status: {{$json["results"] ? ($json["results"][0]["ok"] ? "UP ✅" : "DOWN ❌") : ($json["ok"] ? "UP ✅" : "DOWN ❌")}}
Status Code: {{$json["results"] ? ($json["results"][0]["status_code"] || "N/A") : ($json["status_code"] || "N/A")}}
Latency: {{$json["results"] ? ($json["results"][0]["latency_ms"] + " ms") : ($json["latency_ms"] + " ms") || "N/A"}}
Error: {{$json["results"] ? ($json["results"][0]["error"] || "None") : ($json["error"] || "None")}}

Save

7. Configure Python Check

Change URL from http://python:8000/check to http://python:8000/health

8. Test the workflow

Execute the workflow
n8n will call your Python service and get results back
If a monitored site transitions, it'll send you a Telegram message according to the parameters you set.

Finally, you should get a response like the above (make sure to edit parameters, including URL to monitor)

Summary

You’ve now successfully built a fully automated monitoring pipeline using Python and n8n with real-time alerts and total control over your automation.

You can always swap your Telegram node with Slack/Email node, monitor multiple environments and even track your last alert timestamp.

Excited to see what you build!

Bringing this back... "AI Tools Every Developer Should Know in 2025". Any other tool you use or know? Drop them in the comments :)

Adetola Jesulayomi — Tue, 29 Apr 2025 11:05:22 +0000

Adetola Jesulayomi

Feb 25 '25

AI Tools Every Developer Should Know in 2025

#ai #machinelearning #developer #programming

Comments

4 min read

Check out my recent post!!! A simple walkthrough on building an AI Agent that gets Gmail messages straight to Telegram with n8n. Let me know your thoughts and tag me when you build yours :)

Adetola Jesulayomi — Thu, 24 Apr 2025 07:37:35 +0000

Adetola Jesulayomi

Apr 24 '25

Building a Simple AI Agent with n8n

#ai #agents #nocode

Comments 2

5 min read

Building a Simple AI Agent with n8n

Adetola Jesulayomi — Thu, 24 Apr 2025 07:34:23 +0000

Introduction

I've been playing around with AI Agents for a while now, and in a bit, I'll show you how I built a cool automation agent with n8n that pulls new and recent emails from my Gmail inbox and sends the results to me via Telegram.

It's amazing and simple to use, especially since you won't always need to constantly check your inbox every 10 minutes for new emails. If you've never used n8n, it's a workflow automation tool (drag and drop) that is very powerful, flexible and builder-friendly. You can plug in many APIs, tools, apps, and bots to build literally almost anything.

Let me show you how I did it. I've also made a quick YouTube video walking through the entire build - Build Gmail-to-Telegram AI Agent with n8n

What We're Building:

Trigger a flow when a Telegram message is sent.
Pull the latest email(s) from your Gmail account
Send the email content straight to your Telegram inbox

Tools I Used:

n8n: a tool for building the AI Agent workflow
Gmail account: the inbox I wanted to track
Telegram Bot: where I wanted to receive messages
Google OAuth2: to connect securely to my Gmail
Telegram credentials: to set up Telegram and send messages from my bot

To create this workflow, you'd need to create an n8n account, and once you're all set up, on the homepage, create a new workflow.

Step 1: Create the Telegram Trigger

On your n8n canvas, click "Add step" and select Telegram on the pop-up, click "On Message"
Set up the Telegram Trigger node by creating new credentials. Go to Telegram BotFather
Create a bot (you’ll get a token - copy that)
In the Telegram Trigger node, paste your Bot Token in there
Once it's done, select your bot, and it’ll be linked. Test the step by sending a message to the Telegram prompt, and it should appear on the Output page.

Step 2: Create Switch Node

This is where it's decided what to do based on what you typed. The Switch looks at the message you sent in Telegram and checks if it matches the condition (or rules) you've set. If it matches, it routes to the next action. Otherwise, it presents an error.

Click the "+" button on the far right and search for "Switch"
Under "Mode", select "Rules" and under "Routing Rules", drag and drop the file ID of your previous test (the test message you sent previously) so it recognizes texts
Lastly, rename output as "text" and test again (always best to delete previous workflow and test anew)

Step 3: Edit Fields (Set Node)

This Set node allows you to format what data goes into the next steps. It can set new data as well as overwrite data that already exists. Here, I created a clean format that includes the message from Telegram and gives the AI a simple prompt.

Set "Node" to "Manual Mapping"
In "Fields to Set", drag and drop the file ID of your previous test and set it to a "String"

Step 4: Setting up AI Agent Node

This is where the magic begins. This AI Agent is basically the heart; it's what connects with the actual AI model. I passed in a prompt that’s structured with the message from Telegram and a bit of instruction, telling it what kind of output I expect.

You can connect this with Anthropic, OpenAI, or other LLM tools, depending on what you want.

Under "Source for Prompt (User Message)", select "Define Below" and under "Prompt(User Message), drag and drop the file ID of a previous test
Under "System Message", give it a prompt that can read and get emails from your Gmail account tool

Step 5: Set up Anthropic Chat Model

This is the actual chat model doing the heavy lifting. I used the Anthropic Claude model here because it’s great at clean responses and structured outputs.

It takes the Telegram message (processed earlier) and returns a response, which could be a reply, a summary, an insight, or a decision. This lets the agent reply like a real assistant.

You can swap this out for any other LLM — Claude, GPT-4, etc.

Connect Anthropic Chat Model to AI Agent
Set up necessary credentials using the API key from your Anthropic account, as seen below

Step 6: Gmail Get Message (Gmail Node)

Now it’s time to fetch the data. This node connects to Gmail using the credentials you set by connecting your account (OAuth-based).

It pulls recent unread messages from the inbox. Here, you can control how many it fetches or apply filters (from a specific sender, subject, etc.)

Once you set up the credential linking your account, set "Tool Description" to "Set Automatically"
"Resource" as "Message" and "Operation" as "Get Many"
You can choose to set a limit and add filter(s) based on your preference

Step 7: Set up Telegram (Send Message) as output

This is the final step, the response delivery. This node sends a Telegram message back to the bot. It feels like chatting with a real assistant on Telegram, and it's instantly responsive.

Select existing credentials linking your Telegram account, choose "Message" for "Resource", and “Send Message” as the operation
Drag the previous chat ID and Text

Test the workflow, go to your Telegram, and type a prompt. And just like that, you’ve built your own AI email-checking Telegram agent.

This might seem like a simple automation, but it’s actually one of those use cases that proves how powerful AI agents and tools like n8n can be. Plus, you didn’t need to write a single line of code to do it. Imagine combining this with OpenAI or adding voice triggers next...

I made a quick YouTube video walking through the entire build - Build Gmail-to-Telegram AI Agent with n8n. If you try this, tag me on X or LinkedIn — I want to see what you’re building too.

Happy building 🧩

Python Tips for Beginners: A Guide to Writing Clean Code

Adetola Jesulayomi — Tue, 18 Mar 2025 00:06:37 +0000

Learning Python has been one of the most intense experiences in my journey as a developer advocate. When I first started, I quickly realized that Python isn’t only about writing code—it’s also about writing code that’s clear, clean, and easy to maintain. Over time, I had to research a few key tips that change the way you write Python code.

Here’s a comprehensive guide that covers everything from spacing and punctuation to debugging and core concepts. Whether you’re just starting or looking to refine your skills, I hope these tips help you write better Python code.

1. Embrace the Beauty of Spacing and Indentation

One of the first things I learned in Python was how critical spacing and indentation are. Unlike other languages that use braces or keywords to denote blocks of code, Python relies heavily on whitespace to define the structure. This means that even a single misplaced space can lead to errors or unexpected behaviour.

• In Python, indentation is your friend: Always use consistent indentation. It not only keeps your code readable but also avoids syntax errors.
• Blank lines for clarity: Use blank lines to separate functions, classes, and sections within your code. This improves readability and makes it easier for you (and others) to follow the flow of your program.

Remember, clean code isn’t just about getting it to work, it should be easy to read and maintain.

2. Mind Your Punctuation

In Python, punctuation isn’t just a matter of style, it’s part of the syntax. Whether you’re declaring a function, setting up a list, or formatting a string, every comma, colon, and parenthesis matters.

• Colons and function definitions: Always remember that a colon (:) signals the start of an indented block. When defining functions, loops, or conditionals, the colon is non-negotiable.
• Proper use of commas: In lists, tuples, and dictionaries, commas separate the elements. Missing a comma can turn what should be a simple data structure into a syntax error that’s hard to debug.
• Quotation marks for strings: Consistency matters. Whether you choose single or double quotes, stick with one style to maintain uniformity across your code.

Getting the punctuation right might seem trivial, but it’s the difference between a program that runs smoothly and one that’s overcome with frustrating bugs.

3. Debugging

No matter how experienced you are, bugs are inevitable. What sets a great developer apart is not the absence of bugs, but the ability to efficiently track them down and fix them.
• Print statements are a good start: Sometimes, simply printing out variables at critical points in your code can help you understand what’s going wrong.
• Break down the problem: If a bug seems overwhelming, try to isolate the issue. Often, the problem becomes much clearer when you narrow down the scope.

Debugging is as much an art as it is a science. The more you practice, the more intuitive it becomes.

4. Mastering Core Python Concepts

Understanding Python’s core concepts is like having a strong foundation when building a house. Without it, even the best tools can’t help you create stable and scalable code.

• Data Structures and Algorithms: I can’t stress enough how important it is to understand lists, dictionaries, sets, and tuples. These aren’t just abstract concepts—they’re the building blocks for every application you’ll write.

• Error Handling: Learn to use try-except blocks effectively. Catching exceptions gracefully can mean the difference between a crashing program and a robust application.

5. Explore Python Shortcuts and Best Practices

Python offers a host of shortcuts and syntactic sugar that can make your code more elegant and concise. Here are a few that have helped me along the way:

• List comprehensions: These are a neat way to create lists in a single line. They’re not just shorter—they’re often more readable once you get the hang of them.
• F-strings: Introduced in Python 3.6, f-strings make string formatting a breeze. They’re more readable than traditional methods and can help prevent common mistakes.
• Context managers: Using the with statement for file operations and other resource management tasks ensures that your resources are properly cleaned up, even if an error occurs.

These shortcuts aren’t just about writing less code—they’re about writing better, more Pythonic code. Embracing them can help you become a more efficient developer.

Final Thoughts

Learning Python is a journey filled with small wins, occasional drawbacks, and constant learning. I’ve shared these tips because I believe that every beginner deserves to have a smoother, more enjoyable path as they navigate Python. What I’ve learned along the way has shaped my approach to coding, and I hope it helps you, too.

AI Tools Every Developer Should Know in 2025

Adetola Jesulayomi — Tue, 25 Feb 2025 11:15:25 +0000

The technological landscape is shifting fast—way beyond what we once knew. We’re now in an era where emerging technologies like Web3, AI, IoT, and autonomous systems are not just buzzwords but are actively redefining how we build, interact, and innovate.

And with AI evolving rapidly, developers can’t afford to sit on the sidelines. Whether you’re a backend engineer, a front-end developer, or deep into MLOps, AI is reshaping software development.

As someone deeply invested in developer advocacy for AI tools, I’m actively learning, experimenting, and figuring out how these tools fit into real-world developer workflows. And if you’re looking to stay ahead, understanding AI tools is non-negotiable.

Here are five AI tools every developer should know about and why they matter.

1. Perplexity AI – AI-Powered Research Assistant

Why Developers Need It:

We all know the struggle of sifting through endless documentation, Stack Overflow threads, and research papers. Perplexity AI is solving that problem by acting as an AI-powered research assistant that pulls in accurate, real-time information from various sources, making technical research faster and more efficient.

What You Should Know:

It’s like ChatGPT but for research, meaning it sources information with actual citations.
You can use it to find the latest AI advancements, technical explanations, and even code snippets.
It significantly reduces time spent searching for solutions, allowing you to focus on building.

✅ Pro Tip: Try using it for debugging, learning new AI concepts, or even exploring advanced ML techniques.

2. OpenAI Codex – AI-Powered Code Generation

Why Developers Need It:

If you’ve ever wished coding was faster and less repetitive, OpenAI Codex is your best friend. Built on GPT-4, it understands natural language prompts and generates working code snippets across multiple programming languages—including Python.

What You Should Know:

It’s the engine behind GitHub Copilot, meaning it can write, refactor, and optimize your code.
Works with dozens of programming languages, making it useful across different projects.
Integrates seamlessly into VS Code, JetBrains, and other IDEs.

✅ Pro Tip: Don’t just use it for autocompleting code, test its ability to explain complex algorithms in plain language.

3. Hugging Face – The AI Model Hub

Why Developers Need It:

Hugging Face is the go-to platform for pre-trained AI models, making it easier to implement NLP, computer vision, and generative AI without starting from scratch. Whether you're building AI-powered chatbots, recommendation systems, or custom machine-learning models, Hugging Face has ready-to-use models that save time.

What You Should Know:

Hosts thousands of open-source AI models, including **BERT, GPT, Stable Diffusion, and more.
Offers Transformers library, which simplifies integrating AI into your projects.
Works with PyTorch and TensorFlow, making it flexible for different AI stacks.

✅ Pro Tip: Start by fine-tuning a pre-trained model rather than building from scratch—it’ll cut down development time massively.

4. LangChain – AI for Building Context-Aware Apps

Why Developers Need It:

If you’re working with LLMs (Large Language Models) and want to build smart applications that understand context better, LangChain is the tool you need. It makes it easier to connect AI models with APIs, databases, and real-world applications.

What You Should Know:

Designed for chatbots, AI agents, and personalized AI apps.
Supports OpenAI’s GPT, Llama, and other LLMs.
Allows you to combine multiple AI models for better accuracy and efficiency.

✅ Pro Tip: If you're planning to build an AI-powered assistant or automation tool, LangChain will make the development process much smoother.

5. TensorFlow 3.0 & PyTorch – The Core AI Frameworks

Why Developers Need Them:

At the foundation of AI development are TensorFlow and PyTorch, the two most widely used deep learning frameworks. Whether you’re working on AI models, ML research, or production-ready AI applications, understanding at least one of these frameworks is essential.

What You Should Know:

TensorFlow 3.0 is the latest iteration, designed for even better scalability, efficiency, and deployment across various platforms, including mobile and edge computing.
PyTorch is widely loved for its ease of use, flexibility, and strong community support, making it the go-to choice for researchers and developers.
Both frameworks power everything from chatbots to self-driving cars, making them essential tools in AI development.

✅ Pro Tip: Start with PyTorch if you’re experimenting and learning AI, but move to TensorFlow if you need robust production-level deployment.

Final Thoughts

AI is no longer a futuristic concept—it’s happening right now, and developers who embrace it will be the ones shaping the future. The tools covered - Perplexity AI, OpenAI Codex, Hugging Face, LangChain, and TensorFlow/PyTorch—are some of the best resources for seamlessly integrating AI into your development process.

As I continue my Python journey, I’m actively exploring these tools, testing them out, and figuring out the best ways to advocate for them. Because at the end of the day, my goal is simple: to help developers unlock the full potential of AI and build the next wave of innovation.

Are you already using any of these tools? Or do you have other helpful AI tools? Let's talk in the comments! 🚀