Your Personal, Private, and Powerful AI Data Scientist - Built for Impact

"What if every person, regardless of their technical background, could have access to a world-class data scientist that works entirely on their device, never sharing their private information, and costs nothing to use?"

Gemma Data Assistant transforms this vision into reality using Google's groundbreaking Gemma 3n model, creating the world's first truly autonomous, offline-first data science assistant that democratizes access to advanced analytics while preserving absolute privacy.

• 98% of small businesses lack access to professional data analysis capabilities.
• Medical researchers in developing countries can't afford expensive cloud AI services.
• Students and educators are blocked by subscription fees and internet requirements.
• Privacy-sensitive organizations (healthcare, finance, government) can't use cloud-based AI tools.
• Rural areas with limited internet are excluded from the AI revolution.

"A rural clinic in Kenya uses Gemma Data Assistant to analyze patient outcomes and optimize treatment protocols without sending sensitive health data to external servers."

Impact Features:

• Analyze patient data while maintaining HIPAA compliance.
• Identify treatment effectiveness patterns.
• Optimize resource allocation for limited-budget healthcare.

"A university in Bangladesh empowers 500+ students to perform advanced statistical analysis without expensive software licenses or cloud subscriptions."

Educational Benefits:

• Free access to professional data analysis tools.
• Learn by doing with real datasets and Jupyter notebook outputs.
• Offline accessibility for remote and underserved learning environments.

"Environmental scientists in the Amazon rainforest analyze deforestation patterns and climate data completely offline, ensuring sensitive location data remains secure."

Environmental Applications:

• Climate change impact analysis.
• Biodiversity research and conservation.
• Environmental monitoring and reporting.

"A family-owned restaurant chain uses the assistant to analyze sales patterns, optimize inventory, and improve customer satisfaction without hiring expensive consultants."

Business Intelligence:

• Customer behavior analysis and sales forecasting.
• Inventory management and marketing effectiveness.

• 🧠 Mobile-First Architecture: Designed specifically for edge devices.
• 🚀 Efficiency Revolution: Runs on devices with just 8GB of RAM.
• 🔒 Privacy by Design: No data is ever transmitted externally.
• 🌐 Universal Access: Works without internet connectivity.
• 💪 Professional Capabilities: Matches expensive cloud AI services.

Our system uses two coordinated AI agents that work together in a three-stage process to deliver a seamless experience, from user request to final report.

• Stage 1: User Interaction & Planning (app.py)

  • ➡️ 🗂️ User Input: A user uploads a dataset and provides a natural language prompt.
  • ➡️ 🧠 Planner Agent Activated: The system analyzes the request.
  • ➡️ 📚 RAG Search: The Planner consults the knowledge_base.json to find relevant analysis steps.
  • ➡️ 📝 Plan Proposal: The agent generates a high-level analysis plan for the user to review.
  • ➡️ ✅ User Approval: The user approves the plan, which triggers the next stage.

• Stage 2: Autonomous Execution & Self-Healing (coding_agent.py)

  • ➡️ 👨‍💻 Executor Agent Activated: A background agent takes over and begins executing the approved plan task-by-task in a loop.
  • ➡️ Inside the Execution Loop:
    • 1. Code Generation: The agent writes Python code for the current task.
    • 2. Notebook Execution: The code is run in a Jupyter Notebook cell.
    • 3. Error Check:
      • If Error 💥:
        • ➡️ Self-Healing: The agent uses its RAG system to search the knowledge_base.json for a solution, rewrites the code, and returns to Step 1 to try again.
      • If Success ✅:
        • ➡️ Append Results: The output is saved, and the agent moves to the next task in the plan.
  • ➡️ The loop continues until all tasks in the plan are completed.

• Stage 3: Final Report

  • ➡️ 📋 Analysis Complete: Once the loop finishes, the Executor Agent generates a final, user-friendly summary of the findings.
  • ➡️ 🎁 Deliverables: The user is presented with the summary and the complete, documented Jupyter Notebook.

Minimum Configuration (CPU Mode)

• RAM: 8GB
• Storage: 10GB free space
• CPU: Any modern 64-bit processor

Recommended Configuration (GPU Acceleration)

• GPU: NVIDIA GPU with 4GB+ VRAM (CUDA support)
• RAM: 16GB
• Storage: 10GB free space

• Python 3.9 - 3.11
• Ollama
• Streamlit
• Jupyter, FAISS, Pandas, Scikit-learn, and other libraries listed in requirements.txt.

# 1. Download and install Ollama from https://ollama.com

# 2. Start the Ollama service in a separate terminal
ollama serve

# 3. Download the required AI models
ollama pull gemma:2b
ollama pull nomic-embed-text

# Clone the project repository
git clone https://github.com/MarvelBoy047/Gemma_Ai_DataAssistant.git
cd Gemma_Ai_DataAssistant

# Create and activate a virtual environment
python -m venv venv
# On Windows: venv\Scripts\activate
# On macOS/Linux: source venv/bin/activate

# Install all required Python packages
pip install -r requirements.txt

# Start the Streamlit web application
streamlit run app.py

# Your browser will automatically open to http://localhost:8501

The project's intelligence is driven by a decoupled, dual-agent architecture that communicates through the file system, ensuring robustness and scalability.

Gemma_Ai_DataAssistant/
│
├── 🚀 app.py                 # Core Streamlit UI & "Planner Agent"
│
├── 🤖 coding_agent.py         # Autonomous "Executor Agent" & Self-Healing Logic
│
├── 📚 knowledge_base.json    # Shared RAG database for planning and code correction
│
├── 📦 Requirements.txt         # All Python package dependencies
│
├── 🧩 Installation setup Instructions.md  # nothing extra straight forward steps
|
├── 💡 README.md #explaining why the project even exists
|
├── 🗂️chat_history/        # Communication Bus: Stores user chat logs and approved plans
│   └── <session_id>.json
│
├── 🗂️agent_memory/        # Agent's Logbook: Detailed logs of the Executor's decisions & actions
│   └── <session_id>_memory.json
│
├── 🗂️notebooks/           # Final Deliverables: Stores generated .ipynb files and datasets
│   └── 🗂️<session_id>/
│       ├── <dataset_name>.csv
│       └── <session_id>.ipynb
│
└── planner_kb_index/    # Cached FAISS index for the Planner Agent's knowledge base

• app.py (The Planner & UI):

  • Manages the user-facing Streamlit application.
  • Takes the user's natural language request and uses a FAISS-powered RAG search on the knowledge_base.json to find relevant tasks.
  • Asks Gemma to create a high-level analysis plan, which is then presented to the user for approval.

• coding_agent.py (The Autonomous Executor):

  • Runs in a background thread, constantly monitoring the chat_history directory for new tasks approved by the user.
  • This agent is the workhorse: it generates, executes, and debugs Python code step-by-step.
  • Features a multi-layered, self-healing mechanism that uses the knowledge_base.json to fix its own errors.

• knowledge_base.json (The Shared Brain):

  • A repository of over 100 trusted data science code patterns and task descriptions.
  • It serves both the Planner Agent (for creating plans) and the Executor Agent (for RAG-based error correction).

• Context-Aware Strategy: Analyzes your dataset structure and creates optimal workflows.
• Goal-Oriented Planning: Focuses on delivering actionable insights, not just charts.

• Production-Quality Python: Generates clean, documented, professional code.
• Library Intelligence: Automatically selects appropriate tools (pandas, scikit-learn, etc.).

• Automatic Bug Detection: Identifies and diagnoses code execution failures.
• RAG-Powered Solutions: Searches 100+ proven fixes for similar problems.
• Context-Aware Repair: Considers your specific data when fixing errors.

• ✅ Core offline analysis engine with self-healing RAG.
• ✅ Professional notebook generation.

• 🔄 Advanced statistical methods and ML model recommendations.
• 🔄 Multi-modal analysis (text, images, audio).

• 🔮 Healthcare-specific analysis templates (HIPAA-compliant).
• 🔮 Financial compliance and reporting tools.

We believe in the power of open source to drive global change.

1. Fork the repository.
2. Create a new feature branch (git checkout -b feature/amazing-improvement).
3. Commit your changes and push to your branch.
4. Submit a pull request with a detailed description of your improvement.

This project is licensed under the MIT License. See the LICENSE file for details.

• Google Gemma Team: For creating the revolutionary Gemma model family.
• Ollama Community: For making local AI accessible to everyone.
• The Python Open Source Community: For the incredible libraries that power this tool.

• GitHub Issues: For bugs and feature requests, please open an issue.