DEV Community: Md Abid Hussain

docs-kb cli

Md Abid Hussain — Tue, 01 Jul 2025 11:53:21 +0000

CLI tool to create knowledge base on open source docs using MindsDB Knowledge Base and Ollama. Comes with 🧠 MCP support so that your agent can access it as well.

Overview of MindsDB

MindsDB is an AI federated query engine that enables humans, AI agents, and applications to get highly accurate answers across sprawled and large-scale data sources. It follows the "Connect, Unify, Respond" philosophy:

Connecting to hundreds of data sources
Unifying them through SQL interfaces
Responding to queries using AI models as virtual tables

Knowledge Bases in MindsDB

Knowledge Bases are one of MindsDB's core unification interfaces that index and organize unstructured data for efficient retrieval.

They:

Transform documents, web content, and text into searchable repositories
Enable natural language querying via SQL
Work with other MindsDB components (Views, ML Models, Jobs) for full unification

MindsDB turns scattered data into an intelligent retrieval system — structured or unstructured.

⚙️ Features

📄 Markdown documentation discovery
⚡ Efficient repo syncs via file SHA comparisons
📦 Track multiple repositories with rich metadata
🧩 Model Context Protocol (MCP) server for IDE integrations (VS Code / Cursor)
🔌 Optional GitHub Data Handler in MindsDB for enhanced repo access

In action

Enhance Repository Analysis with MindsDB MCP and Docs-KB MCP

Built With

🧠 MindsDB
🐪 Ollama
🖋 Typer
🚀 FastMCP

🔗 GitHub Repo

👉 docs-kb CLI Demo

🎥 Demo

Building SDKs for MindsDB this Hacktoberfest

Md Abid Hussain — Wed, 30 Oct 2024 19:13:11 +0000

This is a submission for the 2024 Hacktoberfest Writing challenge: Contributor Experience

The Hacktoberfest 2024 was quite special for me.

I have been involved in open source but have only made small contributions. In the past, I also completed the Hacktoberfest challenge in 2022, where I contributed to roadmap.sh through documentations. It was really great experience.

But this hacktoberfest I took a great step towards contributing to open source. During this hacktoberfest I have contributed to MindsDB which is a great platform for building AI from enterprise data, enabling smarter organizations.

My Contribution

I have built Java SDK for MindsDB and also contributed to JavaScript/TypeScript SDK of MindsDB.

It was challenging and took a lot of effort in understanding the MindsDB. There is already SQL api, REST API and Python SDK. I have to built the whole SDK using the reference from those. The REST API client lack some implementation so I have to write the dynamic SQL query and send it via REST API. Python SDK for MindsDB is written very well along with documentation, so I followed that structure to build Java SDK. I have to read the whole documentation from Python SDK , REST API to SQL API. It's like I have memorized the whole Python codebase, SQL api and documentation because I have referenced them so many times that I can't remember. If I ran to any issue I know where to look and what might be causing the issue.

Apart from this I have also contributed to the JS/TS SDK and it was easy because I know what I have to do since I have already built the Java SDK.

I didn't just built it, I performed tests, wrote both documentation and tests.

Below are the links:

OpenSourceSmith - Complete Kit to Forge Your Project

Md Abid Hussain — Sun, 01 Sep 2024 05:56:21 +0000

This is a submission for the Neon Open Source Starter Kit Challenge : Ultimate Starter Kit

My Kit

The OpenSourceSmith starter kit is designed to empower developers by providing a curated collection of open-source project templates. Whether you're a beginner looking to start your first project or an experienced developer seeking to streamline your workflow, our platform offers a wide range of templates to suit your needs.

The kit is not just an idea but a fully functional and live, ready-to-use set

Key Features

Template Discovery: Browse and filter through a diverse collection of templates for frontend, backend, and full-stack applications.
Template Addition: Seamlessly upload your own templates directly from your GitHub repositories and share your work with the community.
CLI Tool: Utilize our CLI tool, open-source-smith, to automate the initial setup process and fetch templates from the OpenSourceSmith platform.
AI Chatbot Assistance: Generate step-by-step instructions for setting up your project using our AI chatbot.

Link to Kit

Kit compromises three components.

Documentation Site:
- GitHub URL: OpenSourceSmithDocs - GitHub
- Live URL: OpenSourceSmithDocs
Website:
- GitHub URL: OpenSourceSmithPlatform - GitHub
- Live URL: OpenSourceSmithPlatform
CLI tool:
- GitHub URL: OpenSourceSmithCLI - GitHub
- NPM URL: OpenSourceSmithCLI

Your Journey

The journey to idea discovery and project building is quite dynamic. I started with creating templates like express template using typescript, but I didn't feel it was much of a solution because there are already tons of templates out there. So I started creating a cli, which at first gives user options to add a project name and select template type (frontend, backend, or fullstack), and I have added project initialization from official packages like Vite, Vue, and Nextjs, which I also felt was not my original idea, just using the already created tools and only my tool acting as an interface. Then I added the above-created template (e.g., express template using typescript), which I uploaded on github and the user can download it from the cli, which I felt very good after creating, but again, I faced the challenge of adding a new template and showing a huge number of templates in the cli, which can be challenging in terms of search and filtering.
After this, I got the idea to build a platform where users can share their templates because everyone is building templates, and I also integrated it with an already-created cli tool. Also, I integrate AI chat support so that users can have a single platform to ask for any query as well.
The name OpenSourceSmith is from the idea that I'm providing a setup to the user to forge their project, which is similar to Anvil (a forging tool) that can be used to create a wide variety of things and tools.

From Docker to Kubernetes: A Journey with Cyclops UI

Md Abid Hussain — Thu, 01 Aug 2024 10:57:58 +0000

From "localhost" to cloud's vast expanse,
Your app's journey, a cosmic trance.
With Docker's might and K8s's art,
Cyclops UI gives it a flying start.

Table of content:

Intorduction
Prerequisites
Pizza shop analogy of docker, kubernetes and cyclopsui
Dockerization of the RAG App
Deploying to Kubernetes with Minikube and Cyclops UI

Intorduction

This guide offers a comprehensive overview of the process involved in transitioning a Python application from a local development environment to a production-ready Kubernetes cluster. By leveraging Docker for containerization and Cyclops UI for simplified cluster management

Prerequisites

What are we going to use

A simple rag project built using langchain, google-gemini and streamlit.
Docker: For containerizing the application and its dependencies.
minikube: To simulate a Kubernetes cluster for local development and testing.
kubectl: To interact with the Kubernetes cluster and manage deployed applications.
Cyclops UI: To simplify Kubernetes cluster management and application deployment.
Gemini Api key

Ensure you have Docker, Minikube, and Kubectl installed on your system before proceeding with this guide.

Project repo: Github

Pizza shop analogy of docker, kubernetes and cyclopsui

Docker: The Pizza Box 🍕

Think of Docker as a perfect pizza box. It neatly packages your delicious pizza (application) with all its flavorful toppings (dependencies) to ensure a consistent taste (performance) no matter where you enjoy it.

Kubernetes: The Pizza Delivery Fleet 🚚

Kubernetes is like a fleet of speedy delivery cars. It manages and coordinates the delivery of your tasty pizzas (containers) to hungry customers (servers). It can even automatically add more delivery cars when the orders pile up!

Cyclops UI: The Delivery Manager 🧑‍💻

Cyclops UI is the savvy delivery manager overseeing the entire pizza operation. It helps you manage your fleet of delivery cars (Kubernetes cluster), track pizza orders (container status), and make adjustments to keep customers happy.

Dockerization of the RAG App

This section describes the process of containerizing your RAG application using Docker.

Required Libraries:

The application utilizes the following libraries:

langchain
langchain_community
langchain-google-genai
streamlit
python-dotenv
pymupdf
faiss-cpu

Default Port:

By default, the Streamlit application runs on port 8501.

Dockerfile:

Here's the provided Dockerfile with some enhancements:

# Base image with required Python version
FROM python:3.12-slim-bookworm

# Working directory for the application
WORKDIR /app

# Copy requirements file
COPY requirements.txt requirements.txt

# Install dependencies based on requirements
RUN pip install -r requirements.txt

# Copy all application files
COPY . .

# Expose Streamlit port (optional, depending on deployment scenario)
EXPOSE 8501

# Run the Streamlit application
CMD ["streamlit", "run", "main.py"]

Dockerfile Breakdown:

The provided Dockerfile defines the steps to create a containerized version of your application. Here's a breakdown of each line:

Base Image: FROM python:3.12-slim-bookworm - This line specifies the base image for the container. We use python:3.12-slim-bookworm because it provides a lightweight Python 3.12 environment.
Working Directory: WORKDIR /app - This sets the working directory within the container to /app. This directory will hold all your application files.
Copy Requirements: COPY requirements.txt requirements.txt - This copies the requirements.txt file, which lists all the Python libraries your application needs, into the container's /app directory.
Install Dependencies: RUN pip install -r requirements.txt - This line installs all the required libraries listed in requirements.txt using pip.
Copy Application Files: COPY . . - This copies all files and directories from your current directory (where the Dockerfile resides) into the container's /app directory. This includes your Python script (main.py), models, and any other application files.
Expose Port (Optional): EXPOSE 8501 (Optional) - This line exposes port 8501, which is the default port used by the Streamlit application. This allows you to access the application from outside the container if needed.
Run Streamlit: CMD ["streamlit", "run", "main.py"] - This sets the default command for the container. It instructs the container to run streamlit run main.py when it starts, launching your Streamlit application.

Building the Docker Image:

To create the Docker image for your RAG application, run the following command in your terminal (replace your-rag with your desired image name):

docker build -t your-rag .

Running the app

Locally:

streamlit run main.py

Using Docker:

docker run -e GOOGLE_API_KEY=your_gemini_api_key -p 8501:8501 your-rag

Now your app is running:

Upload and chat with document.

Deploying to Kubernetes with Minikube and Cyclops UI

Installing Cyclops UI and running it locally
Make sure minikube and kubectl are installed and running. Installation guide for cyclops can be found at Cyclops Docs.

To install Cyclops in your cluster, run commands below:

kubectl apply -f https://raw.githubusercontent.com/cyclops-ui/cyclops/v0.8.2/install/cyclops-install.yaml && kubectl apply -f https://raw.githubusercontent.com/cyclops-ui/cyclops/v0.8.2/install/demo-templates.yaml

To run cyclops, run command below:

kubectl port-forward svc/cyclops-ui 3000:3000 -n cyclops

Cyclops UI is now running at http://localhost:3000

Steps to deploy app
The docker image of app is already published at docker hub hub.docker.com/mdabidhussain/your-rag. You can also use this image or create one and publish to docker hub by following documentation. Docker Workshop. It will be great if you try to deploy your own dockerize application

Click on button Add module and new page will open
In module select drop down select app-template
Add name for module
In the general options under Define Module section. Fill the name of image you want to use (mdabidhussain/your-rag in this case) and the tag of that image you want to use (latest in this case). Add environment variables if needed (in this case we need GOOGLE_API_KEY)
Under Scaling options add the necessary scaling configuration. For this app I have gone with default.
Under Network option expose the port on which your app run (8501 in this case for streamlit app).
Finally click on Save button. Module status will updated to green if you have properly configure the app deployment.

Now all that is left is to expose your-rag application outside the cluster:

kubectl port-forward svc/your-rag 8501:8501

which follow syntax like

kubectl port-forward svc/<module_name> <port_to_exposed>:<port_to_map>

Now your application is running on localhost:8501

Upload document and chat.