DEV Community: Mohsin Rashid

I Built a CLI That Makes Commands Fight and Tells You Who Wins

Mohsin Rashid — Sun, 15 Feb 2026 10:04:54 +0000

This is a submission for the GitHub Copilot CLI Challenge

What I Built

clash — a Rust CLI tool that benchmarks commands head-to-head, measuring both execution time and peak memory usage.

Tools like hyperfine only measure time. But when comparing garbage-collected languages (Python, Node.js) against non-GC ones (Rust, C), memory is half the story. clash gives you the full picture:

⏱ Time stats (mean, min, max, std dev) across multiple runs
💾 Peak memory (RSS) tracked in real-time via background thread
📊 Colored bar charts and tables in your terminal
📁 JSON export for CI pipelines

clash "python sort.py" "node sort.js" "sort_rust" --runs 5

Demo

Repo: github.com/mohsinrashid64/clash-cli

git clone https://github.com/mohsinrashid64/clash-cli.git
cd clash-cli
cargo install --path .

# Run the included Python vs Node vs Rust demo
rustc -O -o benchmarks/sort_sum_rust benchmarks/sort_sum.rs
clash "python benchmarks/sort_sum.py" "node benchmarks/sort_sum.js" "benchmarks/sort_sum_rust" --runs 5

The repo includes identical benchmark scripts in all three languages (generate 2M numbers, sort, compute sum) so you can reproduce this instantly. Check the README for more examples across Windows, macOS, and Linux.

My Experience with GitHub Copilot CLI

AI CLI tooling was central to building clash. The biggest wins:

Architecture — Went from a vague "performance monitor" idea to a focused benchmark comparator through AI-guided scoping. It picked the right Rust crates (sysinfo, comfy-table, indicatif, owo-colors) and designed the module structure.
The hard part — real-time memory tracking — Monitoring peak RSS of a child process requires a background thread polling sysinfo every 30ms with Arc<AtomicU64> for lock-free peak tracking. Getting this cross-platform (especially Windows) would have taken days without AI assistance.
Rapid iteration — When sysinfo APIs had changed between versions, the AI diagnosed and fixed it immediately. The entire tool went from idea to polished release build in a single session.

The AI didn't just write code — it acted as a Rust ecosystem expert. That's what made shipping a polished CLI tool in one day actually possible.

RAG Web Scraping

Mohsin Rashid — Mon, 11 Nov 2024 07:47:18 +0000

What I Built

I have built a Retrieval-Augmented Generation (RAG) system that leverages Ollama's nuextract model to scrape and extract specific content from HTML documents. The system first extracts content from the HTML, splits it into chunks, and stores the embeddings in a PostgreSQL database using PgVector. With the help of Ollama's nuextract, the model processes the HTML content and provides relevant results based on custom queries. The entire process integrates HTML content scraping with powerful vector search capabilities, enabling the extraction of precise and useful data from complex web pages.

Demo

Link to GitHub

Ollama: I used Ollama’s nuextract model to generate embeddings from the HTML content and perform scraping operations based on custom queries.
PgVector: This tool helped store and manage the embeddings in PostgreSQL. I used PgVector to handle vector-based search and retrieval from the HTML data stored in the database.
PostgreSQL: The vectorized data from HTML content was stored in a PostgreSQL database, making it easy to scale and query for relevant data.
Docker: I utilized Docker to run PgVector in a containerized environment, which simplified the setup and ensured a smooth deployment process.
LangChain: LangChain was used to build the retrieval chain, connecting the embeddings with Ollama's nuextract model for efficient query processing and data extraction.
Jupyter Notebook: The project is designed to be run within a Jupyter Notebook, providing a convenient and interactive way to load, process, and query the data.

Sample HTML Content

Code Demo

Final Thoughts

This project demonstrates the potential of combining modern LLMs with vector-based retrieval techniques to efficiently scrape and extract meaningful information from HTML documents. Integrating PgVector with Ollama's nuextract allows for high-quality, scalable web scraping operations, which can be applied to a variety of use cases, from automated data extraction to content aggregation.

The overall experience of building this project was rewarding, especially exploring the power of vector embeddings and retrieval augmented generation for real-world tasks like web scraping. The combination of PgVector, Ollama, LangChain, and the nuextract model makes for a powerful toolset that can be extended to different AI applications requiring efficient content extraction from complex documents.

This submission is eligible for the following prize categories:

Open-source Models from Ollama: This project utilizes Ollama's nuextract model for extracting structured data from HTML content.
Vectorizer: The use of PgVector for storing and retrieving document embeddings qualifies this project for the Vectorizer Vibe category.

How to Create Virtual Environments in Python

Mohsin Rashid — Sun, 29 Sep 2024 07:53:44 +0000

Python virtual environments are essential for managing dependencies and avoiding conflicts between projects. This guide will walk you through the process of creating and activating a virtual environment in Python.

Step 1: Navigate to Your Project Directory

Open your terminal and navigate to the directory where you want to set up your Python virtual environment. You can do this using the cd command:

cd /path/to/your/project

Step 2: Create the Virtual Environment

In the terminal, enter the following command to create a virtual environment. The name .venv is commonly used, but you can choose any name you prefer:

python3 -m venv .venv

Step 3: Define Your Project Dependencies

Create a text file named requirements.txt in your project directory. In this file, list the Python libraries you want to install for your project. For example:

flask
requests
numpy

Step 4: Activate the Virtual Environment

To start using the virtual environment, you need to activate it. Use the following command based on your operating system:

For Windows:

.\.venv\Scripts\activate

For macOS/Linux:

source .venv/bin/activate

Once activated, your terminal prompt will change to indicate that you are now working within the virtual environment.

Step 5: Upgrade `pip`

It’s a good practice to ensure that pip is up-to-date. Run the following command to upgrade pip:

.venv\Scripts\python.exe -m pip install --upgrade pip

Step 6: Install Project Dependencies

Finally, install the Python libraries listed in your requirements.txt file by running:

pip install -r requirements.txt

RAG with OLLAMA

Mohsin Rashid — Thu, 13 Jun 2024 07:04:22 +0000

In the world of natural language processing (NLP), combining retrieval and generation capabilities has led to significant advancements. Retrieval-Augmented Generation (RAG) enhances the quality of generated text by integrating external information sources. This article demonstrates how to create a RAG system using a free Large Language Model (LLM). We will be using OLLAMA and the LLaMA 3 model, providing a practical approach to leveraging cutting-edge NLP techniques without incurring costs. Whether you're a developer, researcher, or enthusiast, this guide will help you implement a RAG system efficiently and effectively.

Note: Before proceeding further you need to download and run Ollama, you can do so by clicking here.

The following is an example on how to setup a very basic yet intuitive RAG

Import Libraries

import os
from langchain_community.llms import Ollama
from dotenv import load_dotenv
from langchain_community.embeddings import OllamaEmbeddings
from langchain.document_loaders import TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.vectorstores import Chroma
from langchain.chains import create_retrieval_chain
from langchain import hub
from langchain.chains.combine_documents import create_stuff_documents_chain

Loading The LLM (Language Model)

llm = Ollama(model="llama3.1", base_url="http://127.0.0.1:11434")

Setting Ollama Embeddings

embed_model = OllamaEmbeddings(
    model="llama3.1",
    base_url='http://127.0.0.1:11434'
)

Loading Text

text = """
    In the lush canopy of a tropical rainforest, two mischievous monkeys, Coco and Mango, swung from branch to branch, their playful antics echoing through the trees. They were inseparable companions, sharing everything from juicy fruits to secret hideouts high above the forest floor. One day, while exploring a new part of the forest, Coco stumbled upon a beautiful orchid hidden among the foliage. Entranced by its delicate petals, Coco plucked it and presented it to Mango with a wide grin. Overwhelmed by Coco's gesture of friendship, Mango hugged Coco tightly, cherishing the bond they shared. From that day on, Coco and Mango ventured through the forest together, their friendship growing stronger with each passing adventure. As they watched the sun dip below the horizon, casting a golden glow over the treetops, they knew that no matter what challenges lay ahead, they would always have each other, and their hearts brimmed with joy.
    """

Splitting Text into Chunks

text_splitter = RecursiveCharacterTextSplitter(chunk_size=512, chunk_overlap=128)
chunks = text_splitter.split_text(text)

Creating a Vector Store (Chroma) from Text

vector_store = Chroma.from_texts(chunks, embed_model)

Creating a Retriever

retriever = vector_store.as_retriever()

Creating a Retrieval Chain

chain = create_retrieval_chain(combine_docs_chain=llm,retriever=retriever)

Retrieval-QA Chat Prompt

retrieval_qa_chat_prompt = hub.pull("langchain-ai/retrieval-qa-chat")

Combining Documents

combine_docs_chain = create_stuff_documents_chain(
    llm, retrieval_qa_chat_prompt
)

Final Retrieval Chain

retrieval_chain = create_retrieval_chain(retriever, combine_docs_chain)

Invoking the Retrieval Chain

response = retrieval_chain.invoke({"input": "Tell me name of monkeys and where do they live"})
print(response['answer'])

DEV Community: Mohsin Rashid

I Built a CLI That Makes Commands Fight and Tells You Who Wins

What I Built

Demo

My Experience with GitHub Copilot CLI

RAG Web Scraping

What I Built

Demo

Sample HTML Content

Code Demo

Final Thoughts

How to Create Virtual Environments in Python

Step 1: Navigate to Your Project Directory

Step 2: Create the Virtual Environment

Step 3: Define Your Project Dependencies

Step 4: Activate the Virtual Environment

Step 5: Upgrade pip

Step 6: Install Project Dependencies

RAG with OLLAMA

Import Libraries

Loading The LLM (Language Model)

Setting Ollama Embeddings

Loading Text

Splitting Text into Chunks

Creating a Vector Store (Chroma) from Text

Creating a Retriever

Creating a Retrieval Chain

Retrieval-QA Chat Prompt

Combining Documents

Final Retrieval Chain

Invoking the Retrieval Chain

Step 5: Upgrade `pip`