Cloud//Base — Cloud Knowledge Assistant

A production-grade, containerized Retrieval-Augmented Generation (RAG) system engineered to deliver low-latency, interview-grade explanations across core Cloud, DevOps, and Infrastructure domains.

Cloud//Base combines a curated Markdown knowledge base, local HuggingFace embeddings, FAISS semantic retrieval, Gemini, and a Streamlit interface to provide grounded technical answers with transparent source inspection and retrieval telemetry.

📸 Interface & Screenshots

1. System Overview & Interface

The main Cloud//Base interface provides system status, supported knowledge domains, retrieval depth, suggested interview topics, and the primary question interface.

2. Grounded Technical Explanation

Cloud//Base transforms retrieved knowledge into a structured technical explanation designed for both learning and interview preparation.

3. Real-Time Latency & Retrieval Telemetry

Each query exposes runtime telemetry including total latency, local vector retrieval latency, Gemini generation time, and the number of retrieved context chunks.

4. Vector Source Inspection

The retrieved knowledge chunks can be inspected directly, including their originating Markdown file, similarity score, and retrieved content.

5. Multi-Stage Container Runtime

The application is packaged and executed as a Docker container, providing a reproducible runtime environment for Cloud//Base.

🏛️ System Architecture

┌─────────────────────────────────────────────────────────────┐
│                    Knowledge Base (.md)                     │
│  AWS • Docker • Kubernetes • Linux • Terraform • Networking │
└──────────────────────────────┬──────────────────────────────┘
                               │
                               │ MarkdownHeaderTextSplitter
                               ▼
┌─────────────────────────────────────────────────────────────┐
│                Local HuggingFace Embeddings                 │
│              all-MiniLM-L6-v2 • CPU • ₹0 Cost              │
└──────────────────────────────┬──────────────────────────────┘
                               │
                               │ Normalized Vectors
                               ▼
┌─────────────────────────────────────────────────────────────┐
│                     FAISS Vector Store                      │
│            Local Cosine Distance Similarity Index           │
└──────────────────────────────┬──────────────────────────────┘
                               │
                               │ Top-K Semantic Chunks
                               ▼
┌─────────────────────────────────────────────────────────────┐
│                 Gemini 3.5 Flash Lite LLM                   │
│             Grounded Prompt Synthesis + Fallback            │
└──────────────────────────────┬──────────────────────────────┘
                               │
                               ▼
┌─────────────────────────────────────────────────────────────┐
│                 Streamlit Web Interface                     │
│              Dark UI + Real-Time Telemetry                  │
└─────────────────────────────────────────────────────────────┘

🔄 RAG Pipeline

Cloud//Base follows a retrieval-first architecture:

User Question
      │
      ▼
Question Embedding
      │
      ▼
FAISS Similarity Search
      │
      ▼
Top-K Relevant Chunks
      │
      ▼
Retrieved Context + User Question
      │
      ▼
Grounded Gemini Prompt
      │
      ▼
Structured Technical Answer
      │
      ├──────────────► Retrieved Sources
      │
      └──────────────► Retrieval Telemetry

The system separates the retrieval stage from the generation stage, allowing the retrieved context and source information to be inspected alongside the generated answer.

✨ Key Technical Features

🧠 Retrieval-Augmented Generation

Cloud//Base retrieves relevant information from a curated Cloud, DevOps, and Infrastructure knowledge base before generating an answer.

This allows responses to be grounded in the project's own technical documentation.

⚡ Local Vector Retrieval

FAISS is used as the local vector store for semantic similarity search.

The local retrieval pipeline avoids the need for an externally hosted vector database.

💰 Zero-Cost Embedding Pipeline

Embeddings are generated locally using:

sentence-transformers/all-MiniLM-L6-v2

The embedding model runs locally on CPU without requiring a paid embedding API.

📚 Curated Technical Knowledge

The knowledge base is organized into Markdown files covering:

AWS
Docker
Kubernetes
Linux
Networking
Terraform

🎯 Structured Technical Answers

Responses are organized around technical sections such as:

Executive Definition & Core Value
Architecture & Technical Mechanics
Production Best Practices
Interview Q&A / Key Takeaway

This makes the application useful for both technical learning and interview preparation.

🔎 Source Grounding

Retrieved chunks can be inspected directly.

The interface exposes information including:

Source Markdown file
Similarity score
Retrieved content
Number of retrieved chunks

📊 Retrieval Telemetry

Each query provides runtime information including:

Total latency
Local retrieval latency
Gemini generation latency
Number of context chunks retrieved

🐳 Dockerized Runtime

The application can be packaged into a Docker image and run as a container, providing a consistent runtime environment independent of the local Python installation.

🛠️ Technology Stack

Layer	Technology
Language	Python
UI	Streamlit
RAG Framework	LangChain
LLM	Google Gemini
Embeddings	HuggingFace Sentence Transformers
Embedding Model	`all-MiniLM-L6-v2`
Vector Store	FAISS
Knowledge Format	Markdown
Containerization	Docker
Version Control	Git / GitHub

📂 Project Structure

cloud-knowledge-assistant/
│
├── app/
│   ├── __init__.py
│   ├── embeddings.py         # HuggingFace & FAISS index management
│   ├── ingestion.py          # Markdown header chunking pipeline
│   ├── main.py               # Streamlit UI & telemetry dashboard
│   ├── rag.py                # LangChain prompt chaining & Gemini routing
│   └── retrieval.py          # Similarity search helper utilities
│
├── assets/
│   ├── 01-landing-ui.png
│   ├── 02-query-response.png
│   ├── 03-telemetry-metrics.png
│   ├── 04-grounded-sources.png
│   └── 05-docker-running.png
│
├── data/
│   └── vectorstore/
│       └── ...
│
├── knowledge/
│   ├── aws.md
│   ├── docker.md
│   ├── kubernetes.md
│   ├── linux.md
│   ├── networking.md
│   └── terraform.md
│
├── .dockerignore
├── .env.example
├── .gitignore
├── Dockerfile
├── requirements.txt
└── README.md

🚀 Quickstart

1. Clone the Repository

git clone https://github.com/<your-username>/cloud-knowledge-assistant.git
cd cloud-knowledge-assistant

2. Create the Environment File

Create a .env file in the project root:

GEMINI_API_KEY="your_google_ai_studio_api_key"
GEMINI_MODEL="gemini-3.5-flash-lite"
EMBEDDING_MODEL_NAME="sentence-transformers/all-MiniLM-L6-v2"
VECTOR_STORE_DIR="data/vectorstore"

Important: Never commit .env or API keys to GitHub.

Use .env.example to document required environment variables without exposing credentials.

🐍 Local Python Execution

Create the Virtual Environment

py -3.12 -m venv venv

Activate the Environment

.\venv\Scripts\Activate.ps1

Verify Python

python --version

Expected:

Python 3.12.x

Install Dependencies

pip install -r requirements.txt

Launch Cloud//Base

streamlit run app/main.py

The application will be available at:

http://localhost:8501

🐳 Docker

Cloud//Base can also be executed inside Docker.

Build the Docker Image

docker build -t cloud-knowledge-assistant:latest .

Run the Container

docker run -d `
  -p 8501:8501 `
  --env-file .env `
  --name cloud-assistant `
  cloud-knowledge-assistant:latest

Access the application at:

http://localhost:8501

Check Running Containers

docker ps

View Container Logs

docker logs cloud-assistant

Stop the Container

docker stop cloud-assistant

Remove the Container

docker rm cloud-assistant

🔐 Environment & Security

Cloud//Base uses environment variables for API credentials and configuration.

Example:

.env
 │
 ├── GEMINI_API_KEY
 ├── GEMINI_MODEL
 ├── EMBEDDING_MODEL_NAME
 └── VECTOR_STORE_DIR

The real .env file should never be committed to source control.

Recommended .gitignore entries:

.env
venv/
__pycache__/
*.pyc

🧪 Example Questions

Cloud//Base can be used to explore technical concepts such as:

Explain ECS vs EKS with an interview answer.

How does chmod 755 work mathematically?

What is the difference between Layer 4 and Layer 7 Load Balancers?

How does Terraform state locking work with DynamoDB?

What is Docker?

What is a Kubernetes Pod?

What is the role of etcd in Kubernetes?

What is a Docker image vs a Docker container?

The retrieved context is shown alongside the generated response so that the grounding of the answer can be inspected.

📊 Query Telemetry

For each question, Cloud//Base tracks:

Metric	Description
Total Latency	Total time taken to process the request
Local Retrieval	Time spent performing FAISS retrieval
Gemini Generation	Time spent generating the final response
Context Chunks	Number of knowledge chunks retrieved

Example telemetry from a query:

TOTAL LATENCY       4.965s
LOCAL RETRIEVAL     0.3274s
GEMINI GENERATION   4.638s
CONTEXT CHUNKS      4 retrieved

🎯 Project Objective

The objective of Cloud//Base is to build a practical RAG application where the underlying retrieval and generation pipeline can be understood and inspected rather than treating the LLM as a black box.

The project demonstrates practical experience with:

Python
   │
   ├── LangChain
   │
   ├── RAG
   │
   ├── Embeddings
   │
   ├── Vector Search
   │
   ├── FAISS
   │
   ├── Gemini
   │
   └── Streamlit
          │
          ▼
        Docker

Name		Name	Last commit message	Last commit date
app		app
assets		assets
knowledge		knowledge
.dockerignore		.dockerignore
.env.example		.env.example
.gitignore		.gitignore
Dockerfile		Dockerfile
README.md		README.md
requirements.txt		requirements.txt

Latest commit

History

Folders and files

Repository files navigation