DEV Community: Nishanth Abimanyu

I Stopped Rebuilding the Telescope and Built a Lens Instead.....

Nishanth Abimanyu — Wed, 04 Mar 2026 10:01:38 +0000

In my previous work translating the Surya Siddhanta (an ancient Indian astronomical text), I spent months doing something I eventually realized was a mistake. I was manually calculating planetary positions to verify Sanskrit verses against modern ephemerides. It was a tedious, repetitive process of building bespoke simulations for a single cultural context.

When I moved on to my Final Year Project focusing on Mayan and Chinese astronomy, I almost fell into the same trap. I started coding a new simulation for the Mayan calendar. Then, I planned to write another one for the Han Dynasty.

I realized I was rebuilding the "telescope" every time I wanted to look at a different star.

That’s when I pivoted to build Sky Culture MCP: a computational microservice that abstracts the orbital mechanics, allowing AI agents to focus on cultural interpretation.

The Lens.....

The core philosophy of this project is simple: Change the lens, not the telescope.

In this architecture, the "Telescope" is the physics engine—the complex math required to calculate where a planet was 2,000 years ago. The "Lens" is the specific cultural context (names, dates, and significance).

I built this using the Model Context Protocol (MCP) to serve as a bridge between high-precision astronomical data and Large Language Models (LLMs) like Claude.

The Tech Stack

Protocol: Model Context Protocol (MCP)
Ephemeris: NASA JPL DE421 (High precision from 1900 BC to 2050 AD)
Physics Engine: Skyfield (Vector astrometry)
Time Standard: Barycentric Dynamical Time (TDB)

How it Works

Instead of asking an LLM to "hallucinate" where Mars was during a specific Mayan Long Count date, the Agent queries my MCP server. The server handles the vector math and returns precise J2000 coordinates.

Here is the primary function signature exposed to the AI:

convert_culture_to_coordinates(culture_id, object_name, date_str)

It takes a cultural input and returns a scientific output. For example:

Input: Culture: mayan, Object: chak_ek, Date: M:9,16,4,10,8
Output: Julian Day Number + Right Ascension & Declination

The Data Structure

The "Lenses" are defined in a JSON library. Here is a snippet of how I map native names to modern identifiers:

{
  "chinese_han": {
    "name": "Chinese (Han)",
    "objects": {
      "yinghuo": {
        "name": "Yinghuo (Fire Star)",
        "modern_id": "mars"
      }
    }
  },
  "mayan": {
    "name": "Mayan",
    "objects": {
      "chak_ek": {
        "name": "Chak Ek (Great Star)",
        "modern_id": "venus"
      }
    }
  }
}

Integration with Claude Desktop

One of the coolest parts of this project was integrating it directly into my daily workflow. By running the engine as a Docker container, I can add it to my claude_desktop_config.json.

{
  "mcpServers": {
    "sky-culture-lite": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "yourname/sky-culture-lite"
      ]
    }
  }
}

Now, when I'm chatting with Claude about a historical text, it has a tool it can call to get ground-truth astronomical data without me needing to open a separate simulation software.

Why This Matters

This project represents a shift in how we use AI for history and science. We shouldn't rely on LLMs to do math (they are bad at it). We should rely on them for interpretation.

By offloading the physics to a deterministic engine (Skyfield) and using the MCP to bridge the gap, I've created a system where the AI can "put on a Mayan lens" or a "Han Dynasty lens" to see the sky exactly as they did—leaving the Agent free to focus on the poetry, the history, and the meaning behind the stars.

Thanks for reading! If you're interested in Archaeoastronomy or MCP, drop a comment below.

This GitHub Repo Is A Literal Money Printer For n8n Developers

Nishanth Abimanyu — Tue, 30 Dec 2025 09:10:16 +0000

If you are an n8n developer, you know the reality: Time is money.

Every hour you spend debugging a broken node or figuring out an authentication flow is an hour you aren't billing. To truly scale your freelance income or your agency, you need speed. You need to deliver high-quality automation in a fraction of the time.

This GitHub repository that is the secret weapon for doing exactly that. It’s called the Automation WorkBook, and it is designed to 10x your workflow development by giving you a library of verified, sellable solutions.

How This Repo "10x-es" Your Development

Most developers start every project with a blank canvas. That is the slow lane.

The Automation WorkBook allows you to skip the first 90% of the work. Instead of building from scratch, you pull pre-built, industry-standard workflows that handle the heavy lifting for you.

Need a complex RAG Chatbot? Don't build the vector store logic from zero. Import the "RAG Chatbot for Company Documents" workflow.
Need to scrape data? Stop fighting with selectors. Use the "Ultimate Scraper Workflow".

By using these templates, you move straight to customization and delivery. You deliver in hours what takes other developers days.

The Money Angle: Sell "Verified" Solutions

The problem with most n8n repositories is that they are full of "junk" code—scraped from community forums, untested, and often broken. You can't sell that to a client.

This repository is different because it is Problem-First, not Tool-First. It was built by analyzing Upwork job postings to see what clients are actually paying for.

Here is how you turn this repo into income:

Sell Lead Generation: Clients pay huge retainers for fresh leads. You can deploy the LinkedIn & Maps Scrapers from the "Sales & Marketing" folder immediately.
Sell AI Support Agents: Use the verified "Intelligent Chatbot" workflows to build customer support systems for e-commerce stores.
Sell Operations Automation: Offer "HR Resume Parsing" or "Invoice Processing" services using the specialized workflows in the Admin and Finance folders.

Proof It Actually Works: The "Personal Notebook"

The biggest confidence booster in this repo is the Personal Notebook.

Unlike generic repos, the author here documents Case Studies of actual high-value projects. They break down the Strategic Planning, the Problem Analysis, and the architecture.

This proves that these aren't just random nodes connected together—they are battle-tested solutions that have solved real business problems.

Conclusion

If you want to earn money with n8n, you need to stop acting like a coder and start acting like a business consultant.

The Automation WorkBook gives you the inventory you need to do that. It saves you time, it gives you sellable products, and it ensures the code you deliver is high-quality.

I Got My Google Account Suspended for This. Now It's an Official VS Code Feature.

Nishanth Abimanyu — Mon, 17 Nov 2025 14:25:34 +0000

A few years ago, during my final year project, I got my Google account suspended for months.

The crime? I was living in the "two-tab hell" every ML developer knows: my Git repo and project in VS Code, and my GPU-powered notebook in a Chrome tab. The workflow was killing me. I'd !git pull in a cell, manually upload datasets, and scp my model checkpoints back and forth. It was slow and painful.

So, I found a hack. A script that used colab-ssh and ngrok (or Cloudflare) to create a reverse tunnel from the Colab VM back to my local machine. I could finally plug my local VS Code directly into the Colab runtime. It was magic... right up until Google's security systems (rightfully) saw this sketchy, unauthenticated backdoor and locked my account for violating the Terms of Service.

Fast forward to now. I see the official announcement: Google Colab is Coming to VS Code.

My first thought wasn't "finally!" It was, "Wait... what?"

Did they just whitelist the exact ngrok hack that got me suspended? Or did they build something else? I had to know. As an open-source contributor, I couldn't just use it; I had to pop the hood and see the engine. I cloned the colab-vscode repo to find out.

Here’s the technical decode of what I found.

The first thing I found is that the extension

Is a brilliant Adapter. It doesn't re-implement a notebook interface it’s a "plugin for a plugin."

File: package.json
What it does: It lists "ms-toolsai.jupyter" as an extensionDependency. This means the Colab extension is just a data source for the official Microsoft Jupyter extension.
File: src/jupyter/provider.ts
What it does: The ColabJupyterServerProvider class is the core of the adapter. It implements the JupyterServerProvider interface that the Microsoft extension expects. When you click "Select Kernel," the Jupyter extension asks this class, "Hey, got any servers?" and this class is responsible for replying.

This is a key insight: they didn't build a new car; they just built a universal adapter that lets you plug Colab's proprietary engine into the "Jupyter" car we all already drive.

The "Front Door"-- How They Solved the `ngrok` Problem

This was the part I cared about. How do you connect without getting banned?

My Hack: I used ngrok to create a reverse proxy. This pokes a hole out of Google's secure VM to a public URL. This is the "backdoor" that got me banned.

The Official Way: I found the answer in src/auth/flows/loopback.ts. They built the complete opposite: a secure, local-only loopback flow.

When you click "Sign In," it doesn't run a tunnel script.

It spins up a tiny, temporary http.createServer() on 127.0.0.1 at a random port.
It opens your browser to the real Google OAuth page, but it passes a redirect_uri pointing to http://127.0.0.1:[your_port].
When you sign in, Google redirects your browser back to your own machine.
The Handler in loopback.ts catches this one request, grabs the authorization code from the URL, and immediately shuts the server down.

This is why it's secure and allowed. It's not a public tunnel. It's a "key exchange" that proves you are the physical user on that exact machine. The refreshToken it gets is then stored securely in VS Code's native SecretStorage via src/auth/storage.ts.

The "Connection"-It's Not SSH, It's an API

So, my hack used SSH. How do they connect?

The answer is in src/colab/client.ts. The extension doesn't use SSH at all. It's all HTTPS.

When you click "New Colab Server," the AssignmentManager (src/jupyter/assignments.ts) calls the ColabClient. This client makes an authenticated POST request to an internal Google API: /tun/m/assign.

This is the real "front door." Google's backend verifies your accessToken (your "ID badge" from the auth step) and sends back a JSON object. The src/colab/api.ts file defines the schema for this, and it's the holy grail: RuntimeProxyInfo.

This RuntimeProxyInfo object is the "key to the runtime" I was missing all those years ago. It contains:

A unique, temporary url (like https_a-b-c.colab.googleusercontent.com).
A separate, temporary token for that specific runtime.

When the Jupyter extension tries to run a cell, the colabProxyFetch function (src/jupyter/assignments.ts) intercepts the request and injects this new token into a custom HTTP header: X-Colab-Runtime-Proxy-Token.

We're not hacking into a VM's Jupyter process. We're an authenticated guest talking to a first-party, managed API proxy.

The "Aha!" Bonus Finds

I kept digging and found two more gems that show the level of thought that went into this.

1. The "Keep-Alive" Hack is Gone.

I used to run while True: time.sleep(60) in a cell. It was dumb. In src/colab/keep-alive.ts, they have a ServerKeepAliveController. It runs a background task every 5 minutes that just calls ColabClient.sendKeepAlive. This is a simple API ping to /tun/m/.../keep-alive/ that resets the idle timer on Google's backend. Clean.

If you are idle, it even pops the "Server is idle" notification in VS Code, and if you click "Cancel" (as in, "cancel the disconnect"), it keeps the pings going.

2. The "LSP Fix" is Brilliant.

This is my favorite part. The Python Language Server (Pylance) has no idea what !pip install or %matplotlib means, so it draws red squiggles under them.

So, did the Colab team write their own Language Server? Nope.

In src/lsp/middleware.ts, they register "LSP middleware." This is code that sits between the Python LSP and your editor. The function filterNonIPythonDiagnostics intercepts all diagnostics (errors) before they're rendered.

It reads the text of the line with the error. If that line starts with ! or %, it just... throws the error away.

It's a simple, perfect, and invisible fix.

The Verdict

So, no. Google didn't just allow the tunnel hack. They built the real, secure, and robust system we were all trying to build ourselves.

I was banned for trying to pick the lock. The official team built a proper front door with an authenticated doorman and gave us all a key. It's the exact workflow I always wanted, and I don't even have to risk my account for it. Well done, team.

This is a submission for the Google AI Studio Multimodal Challenge

Nishanth Abimanyu — Sun, 14 Sep 2025 14:45:43 +0000

What I Built

Symmetria - AI Rangoli Architect represents the evolution of my Hackathon project, now transformed through Google AI Studio's multimodal capabilities into a sophisticated platform that celebrates the rich tradition of Indian Rangoli art. This application serves as both a creative studio and educational portal, seamlessly blending ancient artistic traditions with cutting-edge AI technology to preserve, analyze, and reimagine Rangoli designs through multiple sensory experiences.

The platform addresses the critical challenge of cultural preservation while making traditional art forms accessible to contemporary audiences through interactive technology. By leveraging Gemini's multimodal capabilities, Symmetria bridges generations and geographies, ensuring that this beautiful art form continues to evolve and inspire.

Demo

Live Application: [Symmetria AI Rangoli Architect on Cloud Run]

Video Demonstration: [From SIH Project to Multimodal Experience]

Note: Video demonstration included to showcase features that may use free-tier APIs during judging

How I Used Google AI Studio

Transforming an SIH Concept into Multimodal Reality

My original Smart India Hackathon project focused on digital preservation of Rangoli patterns. With Google AI Studio, I've transformed it into a comprehensive multimodal experience:

Multimodal Integration Strategy:

Gemini 2.5 Pro Vision: Enhanced pattern analysis from basic recognition to sophisticated mathematical and cultural understanding
Live API Capabilities: Added real-time voice interaction and dynamic content generation
Multimodal Content Generation: Created seamless transitions between visual, auditory, and textual experiences

Key Technical Enhancements:

Upgraded from static pattern database to AI-generated designs
Transformed basic analysis into deep mathematical symmetry proofs
Added cultural intelligence and historical context understanding
Implemented real-time voice control and interactive storytelling

Multimodal Features

1. AI-Powered Creation & Remixing

Text-to-Rangoli Generation: Users describe designs ("peacock motifs with 4-fold symmetry") → AI generates entirely new Rangoli images
Style Transformation: Upload existing designs → remix with new materials, colors, or styles through natural language commands
Cultural Authenticity Preservation: AI maintains traditional mathematical principles while enabling creative experimentation

2. Deep Multimodal Analysis

Mathematical Symmetry Prover: AI performs formal group theory analysis, identifying symmetry groups (D4, etc.) with step-by-step visual proofs
Cultural Context Engine: Analyzes designs for regional origins, festival associations, and symbolic meanings
Pattern Complexity Assessment: Evaluates designs using advanced mathematical metrics rooted in traditional principles

3. Artistic Interpretation & Storytelling

Interactive Rangoli Tales: Choose-your-own-adventure stories generated from pattern analysis
Visual-to-Audio Translation: Converts geometric patterns into musical compositions based on symmetry and complexity
Historical Narrative Generation: Creates plausible historical backgrounds and cultural stories for each design

4. Interactive Learning System

AI Cultural Expert: Chat interface for exploring Rangoli history, techniques, and significance
Meditative Creation: Animated drawing experiences that teach traditional techniques through peaceful observation
Adaptive Learning Pathways: Personalized educational journeys based on user interaction patterns

Cultural Significance & Impact

Preservation Through Innovation

Symmetria addresses the urgent need to preserve intangible cultural heritage by:

Digitizing traditional knowledge and techniques
Making ancient art forms accessible to global audiences
Ensuring continuity between generations through technology
Celebrating regional diversity in Rangoli traditions

Educational Value

The platform serves as an educational tool that:

Teaches mathematical concepts through visual art
Preserves cultural knowledge through engaging experiences
Makes traditional art relevant to digital-native generations
Provides accessibility through multiple learning modalities

Technical Achievement

From SIH project to multimodal platform, this evolution demonstrates:

Successful integration of traditional knowledge with modern AI
Effective use of multimodal capabilities for cultural preservation
Scalable architecture for cultural heritage applications
Innovative approach to intangible cultural heritage conservation

Implementation Highlights

User Experience Design:

Sophisticated dark theme with traditional Indian color accents (deep red, black, amber)
Responsive design adapting from desktop sidebar to mobile bottom navigation
Custom animations reflecting traditional Rangoli creation rhythms
Intuitive interface balancing cultural authenticity with modern usability

Technical Architecture:

Cloud-native deployment on Google Cloud Run
Multimodal API integration handling image, text, and voice simultaneously
Real-time processing for immediate visual and auditory feedback
Scalable design supporting multiple concurrent cultural experiences

This project represents the successful evolution of an SIH concept into a sophisticated multimodal platform, demonstrating how traditional technology projects can be transformed through Google AI Studio's advanced capabilities to serve cultural preservation and educational needs.

This submission builds upon my original Smart India Hackathon project, significantly enhanced through Google AI Studio's multimodal capabilities to create a comprehensive cultural preservation and education platform.

Prototyped : Nishanth - Bridging traditional art with modern AI technology

The Simple 4-Step Guide to DHCP Server Configuration for Multiple VLANs

Nishanth Abimanyu — Tue, 09 Sep 2025 14:29:57 +0000

I’ll be honest — it wasn’t easy to put everything into words. I knew the concepts in my head, but when I tried to explain them line by line, the result was confusing…..

I’d write five lines of configs and then have to backtrack because I couldn’t even follow my own article a week later.

That’s when I thought…
Why not add flowcharts? If I’m struggling to explain it, chances are you’ll struggle to follow.

So instead of drowning in paragraphs, I broke it down visually. I created four flowcharts, just enough so you can get a good grasp of how the network fits together without overcomplicating things

How I Set the Stage….

The first step is a blank Packet Tracer canvas.

Press enter or click to view image in full size

The setup includes four PCs, one 2960 switch, and one 2911 router, all connected with straight-through cables. The connections are as follows….

Press enter or click to view image in full size

The first green lights are your first green flags. If anything stays amber or red, don’t hope it fixes itself. It won’t. Check the cable type, port status, and speed/duplex settings. Fix it now, not later.

VLAN Configuration on the Switch
Leaving all four PCs in the default VLAN is like putting Girl Friend and Your Ex-Girl Friend in the same room and then wondering why they are angry.

Broadcast storms aside, you lose segmentation, you lose control, and troubleshooting becomes vibes-based. So I split the network into two crisp lanes…..

Switch> enable
Switch# configure terminal

! Create VLANs
Switch(config)# vlan 10
Switch(config-vlan)# name SALES
Switch(config-vlan)# exit

Switch(config)# vlan 20
Switch(config-vlan)# name ENGINEERING
Switch(config-vlan)# exit

! Assign access ports to VLANs
Switch(config)# interface range fastethernet 0/1-2
Switch(config-if-range)# switchport mode access
Switch(config-if-range)# switchport access vlan 10
Switch(config-if-range)# exit

Switch(config)# interface range fastethernet 0/3-4
Switch(config-if-range)# switchport mode access
Switch(config-if-range)# switchport access vlan 20
Switch(config-if-range)# exit

! Configure trunk port
Switch(config)# interface fastethernet 0/24
Switch(config-if)# switchport mode trunk
Switch(config-if)# switchport trunk allowed vlan 10,20
Switch(config-if)# end

! Save configuration
Switch# copy running-config startup-config
Access ports are the “rooms” (Fa0/1–2 in VLAN 10, Fa0/3–4 in VLAN 20). Fa0/24 is the “corridor” — a trunk that carries tagged traffic from both rooms to the router.

My flowchart here focuses on the hierarchy: create VLANs → assign access ports → make the trunk → allow only 10,20. Minimal surface area, maximum clarity.
**
Quick mental check I always do….**

Switch# show vlan brief
Switch# show interfaces trunk
If a PC in Sales can ping a PC in Engineering without the router, I’ve messed up the VLANs.
If the router sees nothing on a subinterface, the trunk isn’t tagging (or allowed VLANs are wrong).

Router-on-a-Stick — ( Think it like the translator in the middle )
The router is where the two worlds meet. Physically it’s one link, logically it’s multiple lanes. That’s why subinterfaces exist. I picture the router like a bouncer with two counters….

The command encapsulation dot1q .

Router> enable
Router# configure terminal

! Configure subinterface for VLAN 10
Router(config)# interface gigabitethernet 0/0/0.10
Router(config-subif)# encapsulation dot1q 10
Router(config-subif)# ip address 192.168.10.1 255.255.255.0
Router(config-subif)# exit

! Configure subinterface for VLAN 20
Router(config)# interface gigabitethernet 0/0/0.20
Router(config-subif)# encapsulation dot1q 20
Router(config-subif)# ip address 192.168.20.1 255.255.255.0
Router(config-subif)# exit

! Enable physical interface
Router(config)# interface gigabitethernet 0/0/0
Router(config-if)# no shutdown
Router(config-if)# end

! Verify configuration
Router# show ip interface brief
Without it, the router can’t tell which packet belongs to which VLAN. The flowchart here shows the relationship…..

Physical interface up → two subinterfaces → each with its own tag and gateway IP. Once I see both subinterfaces “up/up” in the status, I know inter-VLAN routing is ready.

Every clean network I’ve seen follows the rule “one VLAN, one subnet, one gateway.” You did exactly that with 192.168.10.0/24 and 192.168.20.0/24. Textbook good.

Make the router do the boring work (DHCP)

Static IPs are cute for a lab of one. For four (and growing), it’s just asking for conflicts. So I make the router the DHCP server for both VLANs. Two pools…

I always exclude the gateway addresses first so the pools don’t accidentally hand them out.

Router# configure terminal

! Exclude gateway addresses from DHCP pools
Router(config)# ip dhcp excluded-address 192.168.10.1
Router(config)# ip dhcp excluded-address 192.168.20.1

! Create DHCP pool for VLAN 10 (SALES)
Router(config)# ip dhcp pool SALES_POOL
Router(dhcp-config)# network 192.168.10.0 255.255.255.0
Router(dhcp-config)# default-router 192.168.10.1
Router(dhcp-config)# dns-server 8.8.8.8
Router(dhcp-config)# lease 7
Router(dhcp-config)# exit

! Create DHCP pool for VLAN 20 (ENGINEERING)
Router(config)# ip dhcp pool ENGINEERING_POOL
Router(dhcp-config)# network 192.168.20.0 255.255.255.0
Router(dhcp-config)# default-router 192.168.20.1
Router(dhcp-config)# dns-server 8.8.8.8
Router(dhcp-config)# lease 3
Router(dhcp-config)# end

! Verify DHCP configuration
Router# show ip dhcp pool
And yes, I like giving Engineering a shorter lease — devices churn more, VM labs spin up/down, and shorter leases reduce stale bindings. It’s a tiny choice that makes long-term ops nicer.

Add a second DNS (like 8.8.4.4). If the first resolver flakes, you won’t lose name resolution and assume the whole network is down.

“Helper address” — when you need it, when you don’t
This is a common trap. DHCP is broadcast. Broadcasts don’t cross VLANs. So usually, you put ip helper-address on each L3 interface to relay the request as unicast to the DHCP server.

Router# configure terminal

! Configure DHCP relay on subinterfaces
Router(config)# interface gigabitethernet 0/0/0.10
Router(config-subif)# ip helper-address 192.168.10.1
Router(config-subif)# exit

Router(config)# interface gigabitethernet 0/0/0.20
Router(config-subif)# ip helper-address 192.168.20.1
Router(config-subif)# end

! Verify helper addresses
Router# show running-config | include helper-address
But here’s the catch….

If the router itself is the DHCP server, it already hears the broadcast on each subinterface. There’s nowhere else to forward it. So helper addresses are optional here (not needed).

I still keep a flow segment explaining helper logic, because the moment you move DHCP to a dedicated server (say, an IT/Admin VLAN 30), you’ll need it on each user VLAN subinterface pointing to that server’s IP.

The four-step DHCP dance (watch it happen)
This is my favorite diagram because it gives the protocol a heartbeat….

If you want to be extra sure name resolution works, don’t stop at ping 8.8.8.8. Try ping google.com. If numbers work but names don’t, it’s a DNS issue, not connectivity.

Client side — Human loop

On each PC, I head to Desktop → IP Configuration → DHCP. Then I wait 10–20 seconds. Packet Tracer sometimes takes a breath here. If it stalls, I do a quick release/renew from the PC’s command prompt. No drama.

Expected first four leases:

PC0 → 192.168.10.2
PC1 → 192.168.10.3
PC2 → 192.168.20.2
PC3 → 192.168.20.3
If any PC lands in 169.254.x.x (APIPA), it never heard from DHCP. That usually means VLAN/trunk trouble, or the pool doesn’t match the subnet.

The verification ritual (don’t skip this)
I treat verification like a checklist so I don’t get emotionally attached to “it should work.

On the router — confirm subinterfaces are up, pools exist, bindings are being issued.
! Check DHCP pools
Router# show ip dhcp pool

! View current leases
Router# show ip dhcp binding

! Verify interface status
Router# show ip interface brief
On the switch — VLAN membership is correct, trunk is actually trunking, allowed VLANs include 10 and 20.
! Verify VLAN configuration
Switch# show vlan brief

! Check trunk status
Switch# show interfaces trunk
On the PCs — ipconfig /all shows correct IP, mask, gateway, DNS.

Check IP configuration

ipconfig /all

Test connectivity

ping 192.168.10.1 # Gateway
ping 192.168.20.2 # Cross-VLAN
ping 8.8.8.8 # Internet DNS
Green. Green. Green. Only then I breathe.

For Further Troubleshooting…And Refrence..
GitHub - nishanthabimanyu/Cisco-Packet-Tracer-Workbook-
Contribute to nishanthabimanyu/Cisco-Packet-Tracer-Workbook- development by creating an account on GitHub.
github.com

Press enter or click to view image in full size

If anything fails, go back and check configuration step by step. Common issues include missing ip helper-address commands, incorrect VLAN assignments on switch ports, or firewall rules blocking traffic.

And that’s it! you have successfully built a multi-VLAN network with DHCP services.

The entire process took me about 30 minutes, but the learning will last much longer. Remember to save your configuration with copy running-config startup-config on both switch and router!

This IIT-Backed Startup Can Run Llama 2 on CPUs… No Need GPUs to Run AI Anymore..

Nishanth Abimanyu — Mon, 09 Jun 2025 07:59:52 +0000

I was just opening LinkedIn casually — that usual scroll before sleep, and suddenly one post caught my eye.

Runs LLMs like T5 and Bloom-7B without GPU, just on CPU.

I blinked twice. At first, I thought it’s just another startup doing the same “no GPU required” drama.

We’ve all seen those lines.. “Edge-friendly, lightweight, runs offline...” and then boom — nothing new.

But this one felt different. The name? Kompact AI.

What Even Is Kompact AI? (And Why It Feels Legit)

From what I gathered, Kompact AI is building something called ICAN — a Common AI-Language Runtime. Basically, a system that supports 10+ programming languages and makes AI models run efficiently on CPUs.

Here’s where it gets real….
They’re not just talking about basic models. They’re saying they can run inference, fine-tuning, and even light training of models like T5 and Bloom-7B — on CPUs.

What Exactly Is AI, and Why Does It Need So Much Power?

At its core, AI—particularly deep learning—relies on neural networks that perform massive amounts of matrix computations. These computations are needed for two key processes….

Training

This is when a model learns from data. It adjusts itself based on feedback and gets better with time.
It’s computationally heavy and typically requires specialized hardware like GPUs or TPUs.

Inference.....

Once the model is trained, we use it to make predictions. Inference requires less computational power than training, but it’s still demanding, especially for large models or real-time tasks.

So, What Makes Kompact AI Different from the Rest?

Here’s where Kompact AI stands out: it claims to run heavy AI models like T5 and Bloom-7B on CPUs—no GPUs required. But wait, isn’t that supposed to be impossible?

CPUs
These are general-purpose processors designed for a wide range of tasks. They’re great at complex, sequential logic and have fewer cores (usually 4–16) than GPUs.

GPUs
Designed for parallel tasks, GPUs have thousands of smaller cores optimized for repetitive, matrix-heavy operations, making them ideal for AI.
So how does Kompact AI make running AI models like T5 on a CPU even possible? What kind of tech is happening behind the scenes?

What Could Be Going On Behind the Scenes? Let’s Break It Down.

There are three main factors we need to address to run AI effectively on CPUs.....

Computational Requirements: AI models need substantial computing power
for matrix operations. Can CPUs handle these heavy tasks?
Hardware Capabilities: CPUs have strengths like multi-core processing and large caches, but they lack GPU-level parallelism. How does Kompact AI manage these differences?
Software Optimization: The way the software is written makes a huge difference in how well AI models run on CPUs. What kind of optimizations could make it work?

Let’s dive deeper into these aspects and try to understand what’s going on.

How Do We Simplify AI to Make It Run on a CPU?

Computational Requirements: AI models, especially large language models (LLMs) like T5 or Bloom-7B, have billions of parameters. Running these models, especially for tasks like training, can be computationally intensive. But, is there a way to make these tasks less demanding?
Inference: This is when we use a pre-trained model to make predictions. It’s much less computationally demanding than training.
Fine-tuning: This is when you adjust an already trained model on new data. It’s more demanding than inference but still much lighter than full-scale training.
Could Kompact AI focus on these lighter tasks—like inference and fine-tuning—so that it avoids the heavy computational cost of full-scale training?
Hardware Capabilities: CPUs, while not as parallel as GPUs, are still quite powerful in their own right. Could Kompact AI be taking advantage of things like….

Multiple cores that can handle tasks simultaneously.
SIMD (Single Instruction, Multiple Data), allowing the CPU to process multiple pieces of data within each core.
Large caches that reduce memory latency?

How does Kompact AI tap into these strengths of CPUs to handle AI workloads efficiently?

Software Optimization: Most AI frameworks (like TensorFlow or PyTorch) are designed to take advantage of GPUs. On CPUs, this often leads to underutilization of resources.
Could Kompact AI be doing something radically different with its software optimization to make the most of CPU power?

How Do We Rebuild the AI Solution for CPUs?

What if Kompact AI's approach works by rethinking how AI models are structured and executed? Could it work like this?

Model Optimization: By quantizing, pruning, and distilling large models, could Kompact AI reduce the computational load, making it feasible for CPU-based systems to handle tasks like inference or fine-tuning efficiently?
Leverage CPU Strengths: Could Kompact AI split computations across multiple CPU cores and use SIMD instructions to handle matrix operations without needing GPU-like parallelism?
Optimized Runtime: What if Kompact AI uses a custom runtime environment (maybe something like ICAN) tailored to CPUs, optimizing code execution and minimizing resource usage?

Does this mean we can make large models like Bloom-7B run smoothly on a CPU after all?

How Does It All Come Together to Make AI Work on CPUs?

By combining model optimization, multi-core parallelism, SIMD, and an optimized runtime, how does Kompact AI make running large AI models like Bloom-7B on CPUs actually work?

Could it be that Kompact AI works like this?

Quantized and pruned versions of models that reduce their size, making them manageable on a CPU.
Parallel execution across multiple CPU cores to handle large models by distributing the workload efficiently.
The ICAN runtime ensures minimal overhead, achieving up to 3x the performance of traditional CPU execution in frameworks like TensorFlow or PyTorch.

Is it possible that Kompact AI can bypass the need for GPUs and still deliver solid performance?

So, What’s the Big Picture?

Kompact AI does something groundbreaking: it rethinks how AI models are structured and executed. Could this be the future of AI?

Through techniques like quantization, pruning, and distillation, along with efficient multi-core parallelism and a custom runtime (ICAN), Kompact AI makes AI models run efficiently on CPUs—no GPUs required. Is this the kind of innovation that could democratize AI, making it more accessible for offline and edge devices, where specialized hardware like GPUs may not be available?

hacking

Nishanth Abimanyu — Mon, 09 Jun 2025 07:36:21 +0000

DEV Community: Nishanth Abimanyu

I Stopped Rebuilding the Telescope and Built a Lens Instead.....

The Lens.....

The Tech Stack

How it Works

The Data Structure

Integration with Claude Desktop

Why This Matters

This GitHub Repo Is A Literal Money Printer For n8n Developers

How This Repo "10x-es" Your Development

The Money Angle: Sell "Verified" Solutions

Proof It Actually Works: The "Personal Notebook"

Conclusion

I Got My Google Account Suspended for This. Now It's an Official VS Code Feature.

The first thing I found is that the extension

The "Front Door"-- How They Solved the ngrok Problem

The "Connection"-It's Not SSH, It's an API

The "Aha!" Bonus Finds

1. The "Keep-Alive" Hack is Gone.

2. The "LSP Fix" is Brilliant.

The Verdict

This is a submission for the Google AI Studio Multimodal Challenge

What I Built

Demo

How I Used Google AI Studio

Transforming an SIH Concept into Multimodal Reality

Multimodal Features

1. AI-Powered Creation & Remixing

2. Deep Multimodal Analysis

3. Artistic Interpretation & Storytelling

4. Interactive Learning System

Cultural Significance & Impact

Preservation Through Innovation

Educational Value

Technical Achievement

Implementation Highlights

The Simple 4-Step Guide to DHCP Server Configuration for Multiple VLANs

Check IP configuration

Test connectivity

This IIT-Backed Startup Can Run Llama 2 on CPUs… No Need GPUs to Run AI Anymore..

What Even Is Kompact AI? (And Why It Feels Legit)

What Exactly Is AI, and Why Does It Need So Much Power?

Training

Inference.....

So, What Makes Kompact AI Different from the Rest?

What Could Be Going On Behind the Scenes? Let’s Break It Down.

How Do We Simplify AI to Make It Run on a CPU?

How does Kompact AI tap into these strengths of CPUs to handle AI workloads efficiently?

How Do We Rebuild the AI Solution for CPUs?

How Does It All Come Together to Make AI Work on CPUs?

So, What’s the Big Picture?

hacking

The "Front Door"-- How They Solved the `ngrok` Problem