Forem: Pandi Selvam P

Stop Getting Walls of AI Text — I Built a Tool That Shows Thinking Paths

Pandi Selvam P — Sat, 07 Mar 2026 08:07:00 +0000

🧠 MindRoute — Stop Getting Walls of AI Text. Start Thinking in Paths.

AI chat tools give you one giant answer.

But real thinking doesn't work like that.

When solving a problem, we usually explore multiple approaches:

• analytical
• creative
• practical
• visual

So I built MindRoute — a desktop AI tool that lets you explore multiple thinking paths step-by-step.

Instead of receiving a wall of text, you choose how deep the AI should go.

🚀 What is MindRoute?

MindRoute is an Electron desktop chatbot that changes how we interact with LLMs.

Instead of one response, it generates multiple strategic thinking routes.

You control the depth.

Think of it like Google Maps for ideas.

🧭 Multiple paths
🎯 Choose your route
📊 Go deeper step by step

✨ How It Works

1️⃣ Ask a question

2️⃣ AI generates 4 thinking approaches

Analytical
Creative
Practical
Visual Flowchart

3️⃣ Click a step to explore deeper

4️⃣ AI executes only that step

5️⃣ Responses include

Code blocks
Structured analysis
Mermaid diagrams

6️⃣ New thinking paths appear based on the conversation.

You can change direction anytime.

🧠 Example Thinking Paths

Analytical

① Break down the question
② Examine components
③ Synthesize insights

Creative

① Brainstorm ideas
② Explore unusual options
③ Refine concepts

Practical

① Implementation strategy
② Constraints and risks
③ Action steps

Visual Flowchart

① Map process flow
② Identify decision points
③ Generate Mermaid diagram

📊 Built-In Mermaid Diagrams

MindRoute automatically generates Mermaid flowcharts for visual thinking.

Example:

flowchart TD
A[Problem] --> B{Analyze}
B --> C[Option 1]
B --> D[Option 2]
C --> E[Solution]
D --> E

Rendered directly inside the chat UI.

💻 Developer-Friendly Features

🧭 Guided Thinking Paths

4 structured approaches per question
Click steps to control depth
Visual progress indicators

📊 Mermaid Flowcharts

Generated automatically
Interactive SVG diagrams
Syntax auto-fixing for LLM output

💻 Code Block Rendering

Syntax highlighting
Copy button for every block
Developer fonts (JetBrains Mono, Fira Code)

☁️ Cloud + Local LLM

Ollama Cloud support
Local models supported
Switch between models easily

🖥️ Tech Stack

Desktop: Electron

LLM Backend: Ollama

Frontend: Vanilla HTML / CSS / JS

Diagrams: Mermaid.js

Models Supported:

Llama
Gemma
Mistral
gpt-oss (Ollama Cloud)

⚡ Quick Start

git clone https://github.com/Pandi2352/MindRoute.git
cd MindRoute
npm install
npm start

Local Ollama also works:

ollama run llama3

💡 Why I Built This

Most AI chat tools produce long responses that are hard to navigate.

I wanted something that helps with:

debugging
architecture thinking
research
structured problem solving

So instead of one answer, MindRoute helps you explore the reasoning itself.

🔮 Future Plans

• Streaming responses
• Multiple models per thinking path
• Plugin system
• Conversation export
• Custom thinking templates

🔗 GitHub

If you're interested, check it out here:

https://github.com/Pandi2352/MindRoute

Feedback, ideas, and contributions are welcome.

🧠 Think smarter. Explore deeper. Control your AI conversations.

🤖 GitPulse — AI-Powered GitLab Code Review Agent (Gemini + Ollama)

Pandi Selvam P — Fri, 06 Mar 2026 06:49:26 +0000

🤖 GitPulse — AI-Powered GitLab Code Review Agent (Gemini + Ollama)

Code reviews are one of the most important parts of maintaining code quality.

But in real projects they often suffer from problems like:

reviewers missing security issues

inconsistent review standards

slow feedback cycles

lack of performance checks

repetitive comments on common issues

So I built GitPulse, an AI-powered GitLab code review agent that automatically analyzes merge requests and posts feedback directly on the MR.

🔗 GitHub Repo
https://github.com/Pandi2352/GitPulse-AIAgent

🚀 What GitPulse Does

GitPulse automatically reviews GitLab merge requests using a dual analysis pipeline:

1️⃣ Static code analysis
2️⃣ AI-powered code review

The system then posts structured comments directly on the MR with severity levels and suggestions.

It also generates a quality score for each review.

🧠 Key Features
🔍 Automated Merge Request Reviews

GitPulse listens to GitLab webhooks and triggers reviews automatically when a merge request event occurs.

⚙️ Dual Analysis Pipeline

Before sending code to the AI model, GitPulse runs pattern-based static checks to catch common issues.

Examples:

security vulnerabilities

performance problems

reliability issues

custom rule violations

After that, AI performs deeper analysis.

🤖 AI Provider Support

GitPulse supports multiple AI providers:

Google Gemini

Ollama (local LLMs)

Default model:

gemini-2.0-flash

This makes it possible to run cloud AI or local AI depending on your setup.

📊 Code Review Scoring

Every review gets a quality score from 0 to 100 and a letter grade:

Score Grade
90+ A
80–89 B
70–79 C
60–69 D
<60 F

This makes it easy to quickly evaluate the overall quality of a merge request.

🔔 Real-Time Review Notifications

The system uses WebSockets to stream updates as the review progresses.

You can see phases like:

fetching diffs

running static analysis

AI review

posting comments

in real time.

💬 AI Chat Assistant

GitPulse includes an AI chat interface that understands project context.

You can ask things like:

explain this code

suggest improvements

detect bugs

review architecture

Chat conversations are persisted for later reference.

🧩 Custom Rule Engine

Developers can create custom regex-based rules.

Rules can be:

global

project-specific

Example rule:

Detect usage of console.log in production code
📈 Token Usage Tracking

GitPulse tracks AI usage including:

token consumption

estimated cost

usage trends

This helps teams monitor AI expenses.

📊 Performance Timeline

Every review records the time spent in each phase.

Example phases:

Fetch diffs

Clone repository

Static analysis

AI review

Post comments

This helps identify performance bottlenecks.

📄 Export Review Reports

Reviews can be exported as:

Markdown

JSON

CSV

This is useful for documentation and auditing.

🏗 Architecture

The system uses a React frontend and NestJS backend.

React Client (Vite)
│
│ REST + WebSocket
▼
NestJS Server
│
├── GitLab API Integration
├── AI Providers (Gemini / Ollama)
├── Static Analysis Engine
└── MongoDB
🧰 Tech Stack
Backend

NestJS

TypeScript

Mongoose

Socket.IO

Google Generative AI SDK

Ollama API

Frontend

React

TypeScript

Vite

Tailwind CSS

Database

MongoDB

⚙️ Review Pipeline

When a merge request webhook is received, GitPulse runs an 8-phase review pipeline.

1️⃣ Fetch MR diffs
2️⃣ Clone repository and extract context
3️⃣ Run static analysis and custom rules
4️⃣ Create review record
5️⃣ Send code to AI for analysis
6️⃣ Save comments to database
7️⃣ Post comments to GitLab MR
8️⃣ Compute final score and grade

Each phase is recorded and visualized in the UI.

🚀 Quick Start

Clone the repository:

git clone https://github.com/Pandi2352/GitPulse-AIAgent

Start the backend:

cd server
npm install
npm run start:dev

Start the frontend:

cd client
npm install
npm run dev

Open:

http://localhost:5173
🔐 Security

GitPulse includes multiple security protections:

GitLab tokens encrypted using AES-256-GCM

Webhook validation using secret token verification

Request validation via NestJS ValidationPipe

Traceable requests using x-request-id

💡 Why I Built This

Code reviews are essential but often inconsistent.

I wanted to build a system that:

automatically reviews merge requests

combines static analysis with AI reasoning

provides structured feedback

integrates directly with GitLab workflows

GitPulse is an attempt to bring AI-assisted code review into everyday developer workflows.

🔗 GitHub

If you're interested, check out the project here:

https://github.com/Pandi2352/GitPulse-AIAgent

Feedback and suggestions are welcome.

🚀 NexMind — An Extensible AI Workbench with Pluggable Agents (Ollama + Gemini)

Pandi Selvam P — Fri, 06 Mar 2026 06:38:12 +0000

🚀 NexMind — An Extensible AI Workbench with Pluggable Agents (Ollama + Gemini)

Developers use AI tools for many small tasks every day:

chatting with LLMs

translating text

summarizing documents

testing prompts

experimenting with RAG

But most of the time we end up using multiple different tools.

So I decided to build something to simplify this workflow.

Introducing NexMind — an extensible AI workbench where developers can plug in different AI agents and switch models instantly.

🔗 GitHub Repo:
https://github.com/Pandi2352/NexMind

🧠 What is NexMind?

NexMind is a developer-focused AI workbench that allows you to:

configure multiple AI providers

assign providers per AI agent

integrate vector databases for RAG

switch models without restarting

experiment with AI workflows in one place

It currently supports:

Ollama (local or remote models)

Google Gemini

The system is built so new AI agents can be added easily.

🏗 Architecture

The project is split into two main parts:

nexmind/
├── server/ → NestJS REST API
└── web/ → React + Vite frontend
Backend

NestJS

MongoDB

LangChain

Swagger API docs

Frontend

React 19

TypeScript

Tailwind CSS

React Router

Axios

The architecture is designed to be provider-agnostic, meaning you can switch LLM providers without changing agent logic.

🔌 AI Provider Management

NexMind lets you configure multiple AI providers.

Supported providers:

Ollama (local)

Ollama cloud

Google Gemini

You can:

✔ Add multiple providers
✔ Set an active provider
✔ Assign specific providers per agent

Example setup:

Chat Agent → Gemini
Translator → Ollama
RAG Chat → Ollama + Vector Store

No server restart required.

🧩 Built-in AI Agents

NexMind includes several built-in agents.

💬 Chat

Multi-conversation chatbot with message history and system prompts.

📚 RAG Chat

Chat augmented with retrieval from vector databases.

🌍 Translator

AI-powered text translation with language detection and history.

✂️ Summarizer

Summarize text using styles like:

Bullet points

TL;DR

ELI5

🧠 Prompt Optimizer

Transforms vague prompts into clear structured instructions.

🩺 Health Advisor

Experimental AI assistant for:

symptom analysis

diet suggestions

wellness guidance

🗄 Vector Store Support

For RAG capabilities, NexMind supports:

Pinecone

Chroma

Milvus

Qdrant

Upstash

Each agent can be configured with its own vector store.

⚙️ Example Workflow

Example configuration:

Provider: Gemini → Chat
Provider: Ollama → Summarizer
Vector Store: Pinecone → RAG Chat

This allows each agent to use the best provider for its specific task.

🚀 Quick Start

Clone the repository:

git clone https://github.com/Pandi2352/NexMind

Start backend:

cd server
npm install
npm run start:dev

Start frontend:

cd web
npm install
npm run dev

Open:

http://localhost:5173

From there you can:

add AI providers

configure vector stores

assign agents

start chatting with AI

📦 Tech Stack

Backend

NestJS

MongoDB

LangChain

Swagger

Frontend

React 19

TypeScript

Tailwind CSS

Vite

🔮 Future Plans

Some features I plan to add:

plugin system for custom agents

document ingestion pipelines

streaming responses

OpenAI / Anthropic provider support

workflow automation

💡 Feedback Welcome

This project is still evolving, and I’d love feedback from other developers.

What agents would you like to see next?

⭐ If you find it interesting, feel free to check out the repo and leave a star:

https://github.com/Pandi2352/NexMind