logo updated and flowchart created

Author: Drago-03

README.md

@@ -1,202 +1,71 @@
-# M.A.D.H.A.V.A
+# M.A.D.H.A.V.A.
 
-**Multi-domain Analytical Data Harvesting & Automated Verification Assistant**
+<div align="center">
+  <img src="client/src/logo.png" alt="M.A.D.H.A.V.A. Logo" width="300" />
+  <h1>Multi-domain Analytical Data Harvesting & Automated Verification Assistant</h1>
+</div>
 
-![M.A.D.H.A.V.A Logo](backend/static/images/logo.svg)
+## Overview
 
-M.A.D.H.A.V.A is a powerful real-time RAG (Retrieval Augmented Generation) system that processes streaming data across multiple domains to provide context-enhanced responses. It combines the strengths of vector databases, large language models, and domain-specific APIs to deliver accurate and up-to-date information.
+M.A.D.H.A.V.A. is an advanced AI-powered assistant that provides intelligent analysis and insights across multiple domains:
 
-## Features
-
-- **Real-time Data Processing**: Continuously ingest and process streaming data
-- **Multi-domain Support**: Specialized processing for finance, legal, healthcare, code, and more
-- **Vector Search with Pinecone**: High-performance similarity search using Pinecone vector database
-- **Event-driven Architecture**: Process events asynchronously for improved performance
-- **Domain-specific APIs**: Integrate with specialized APIs for enhanced responses
-- **LangChain Integration**: Leverage LangChain components for advanced RAG pipelines
-- **Modern UI**: Clean, responsive interface for easy interaction
+- 💰 **Finance**: Market analysis and investment insights
+- 🏥 **Healthcare**: Medical research and clinical analysis
+- ⚖️ **Legal**: Case analysis and compliance
+- 💻 **Code Assistant**: AI debugging and code review
+- 📰 **News**: Real-time analysis and trend detection
+- 🛍️ **E-commerce**: Market trends and consumer behavior
 
-## Architecture
-
-M.A.D.H.A.V.A follows a modular architecture with the following components:
+## Features
 
-1. **Vector Store**: Uses Pinecone for efficient vector similarity search
-2. **Embedding Models**: Sentence transformers for high-quality document embeddings
-3. **LLM Integration**: Connects to various LLMs through a unified interface
-4. **Domain Processors**: Specialized processors for different knowledge domains
-5. **Event Queue**: Asynchronous event processing for real-time updates
-6. **API Handlers**: Integration with external domain-specific APIs
-7. **Web Interface**: Modern, responsive UI for user interaction
+- **Domain-Specific Processing**: Tailored analysis for each domain
+- **RAG Implementation**: Advanced retrieval-augmented generation
+- **Real-time Insights**: Instant analysis and recommendations
+- **Interactive Interface**: User-friendly query system
+- **Scalable Architecture**: Built for performance and reliability
 
 ## Getting Started
 
-### Prerequisites
-
-- Python 3.9+
-- Node.js 14+ (for frontend)
-- Docker (optional, for containerized deployment)
-- Pinecone API key (for vector database)
-
-### Installation
-
-1. Clone the repository:
-   ```bash
-   git clone https://github.com/yourusername/madhava.git
-   cd madhava
-   ```
-
-2. Set up the backend:
-   ```bash
-   cd backend
-   python -m venv venv
-   source venv/bin/activate  # On Windows: venv\Scripts\activate
-   pip install -r requirements.txt
-   ```
-
-3. Configure environment variables:
-   ```bash
-   cp .env.example .env
-   # Edit .env with your API keys and configuration
-   ```
-
-4. Run the backend server:
-   ```bash
-   python server.py
-   ```
-
-5. Access the application:
-   Open your browser and navigate to `http://localhost:8000`
-
-### Docker Deployment
-
-1. Build the Docker image:
-   ```bash
-   docker build -t madhava .
-   ```
-
-2. Run the container:
-   ```bash
-   docker run -p 8000:8000 -e PINECONE_API_KEY=your_api_key madhava
-   ```
-
-## Pinecone Integration
-
-M.A.D.H.A.V.A uses Pinecone as its vector database for efficient similarity search. To set up Pinecone:
-
-1. Create a Pinecone account at [pinecone.io](https://www.pinecone.io/)
-2. Create a new index with dimension 384 (for the default embedding model)
-3. Add your Pinecone API key to the `.env` file:
-   ```
-   PINECONE_API_KEY=your_pinecone_api_key
-   PINECONE_ENVIRONMENT=your_pinecone_environment
-   PINECONE_INDEX_NAME=madhava-index
-   ```
-
-## Domain-specific Processing
-
-M.A.D.H.A.V.A supports multiple domains with specialized processing:
-
-- **Finance**: Integration with financial data APIs and market analysis
-- **Legal**: Legal document analysis and regulatory information
-- **Healthcare**: Medical information and healthcare data processing
-- **Code**: Programming assistance and code analysis
-- **Education**: Educational content and learning resources
-- **Travel**: Travel planning and recommendations
-- **Real Estate**: Property analysis and market insights
-
-To add a new domain, extend the `DomainProcessor` class with a new domain-specific method.
-
-## API Reference
-
-### Authentication
-
-- `POST /login`: Authenticate with email and Pinecone API key
-- `GET /logout`: Log out the current user
-- `POST /token`: OAuth2 compatible token endpoint
-
-### Query Endpoints
-
-- `POST /api/query`: Process a query with domain-specific context
-- `GET /api/user/{user_id}/history`: Get query history for a user
-- `GET /alerts`: Get system alerts
-
-### Vector Store Operations
+1. Clone the repository
+```bash
+git clone https://github.com/yourusername/M.A.D.H.A.V.A..git
+cd M.A.D.H.A.V.A.
+```
 
-- `POST /api/documents`: Add documents to the vector store
-- `GET /api/documents`: List documents in the vector store
-- `DELETE /api/documents/{doc_id}`: Delete a document from the vector store
-- `GET /api/stats`: Get vector store statistics
+2. Install dependencies
+```bash
+# Backend
+python -m venv venv
+source venv/bin/activate
+pip install -r requirements.txt
 
-## Development
+# Frontend
+cd client
+npm install
+```
 
-### Project Structure
+3. Start the application
+```bash
+# Backend
+python main.py
 
-```
-madhava/
-├── backend/
-│   ├── static/           # Static assets
-│   ├── templates/        # HTML templates
-│   ├── routes/           # API route handlers
-│   ├── models/           # Data models
-│   ├── pinecone_store.py # Pinecone integration
-│   ├── realtime_rag.py   # RAG implementation
-│   ├── domain_processors.py # Domain-specific processing
-│   ├── api_handlers.py   # External API integration
-│   ├── server.py         # Main server file
-│   └── requirements.txt  # Python dependencies
-├── docs/                 # Documentation
-├── tests/                # Test suite
-└── README.md             # This file
+# Frontend
+cd client
+npm start
 ```
 
-### Adding a New Domain
-
-1. Add a new domain processor method in `domain_processors.py`:
-   ```python
-   async def process_new_domain(self, query: str) -> Dict[str, Any]:
-       # Domain-specific processing
-       domain_data = await self.api_handler.query_domain_api(query)
-       
-       # Use RAG to enhance the response
-       rag_result = await self.rag_orchestrator.process_query(query, domain="new_domain")
-       
-       # Combine results
-       result = {
-           "answer": rag_result["answer"],
-           "context": rag_result["context"],
-           "sources": rag_result["sources"] + ["Domain API"],
-           "metrics": rag_result["metrics"]
-       }
-       
-       return result
-   ```
-
-2. Add a formatting method:
-   ```python
-   def _format_new_domain_response(self, data: Dict[str, Any]) -> str:
-       return f"New Domain Analysis: {data.get('summary', 'No data available')}"
-   ```
-
-3. Update the domain list in the query schema.
+## Architecture
 
-## Contributing
+The application follows a modern microservices architecture:
+- Frontend: React.js with modern UI/UX
+- Backend: FastAPI with Python
+- Database: MongoDB, Redis, Vector Store
+- AI: Gemini API integration
 
-Contributions are welcome! Please feel free to submit a Pull Request.
+## Contributing
 
-1. Fork the repository
-2. Create your feature branch (`git checkout -b feature/amazing-feature`)
-3. Commit your changes (`git commit -m 'Add some amazing feature'`)
-4. Push to the branch (`git push origin feature/amazing-feature`)
-5. Open a Pull Request
+We welcome contributions! Please read our contributing guidelines before submitting pull requests.
 
 ## License
 
 This project is licensed under the MIT License - see the LICENSE file for details.
-
-## Acknowledgments
-
-- [Pathway](https://github.com/pathwaycom/pathway) for real-time data processing
-- [LangChain](https://github.com/langchain-ai/langchain) for LLM application framework
-- [Pinecone](https://www.pinecone.io/) for vector database
-- [FastAPI](https://fastapi.tiangolo.com/) for the web framework
-- [Sentence Transformers](https://www.sbert.net/) for embeddings

backend/gemini_service.py

@@ -0,0 +1,59 @@
+import google.generativeai as genai
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class GeminiService:
+    def __init__(self):
+        self.api_key = os.getenv('GEMINI_API_KEY')
+        if not self.api_key:
+            raise ValueError("GEMINI_API_KEY not found in environment variables")
+        
+        genai.configure(api_key=self.api_key)
+        self.model = genai.GenerativeModel('gemini-pro')
+
+    def generate_response(self, query: str, context: list, domain: str) -> str:
+        # Construct the prompt with context
+        prompt = f"""As an AI assistant specializing in {domain}, analyze the following query and context:
+
+Query: {query}
+
+Context:
+{chr(10).join(f"- {ctx}" for ctx in context)}
+
+Provide a detailed, professional response that:
+1. Directly addresses the query
+2. Uses relevant information from the context
+3. Maintains domain-specific expertise in {domain}
+4. Includes specific facts and metrics when available
+5. Suggests actionable insights when applicable
+
+Response:"""
+
+        try:
+            response = self.model.generate_content(prompt)
+            return response.text
+        except Exception as e:
+            print(f"Error generating Gemini response: {e}")
+            return f"I apologize, but I encountered an error while processing your query. Please try again. Error: {str(e)}"
+
+    def get_domain_insights(self, domain: str, metrics: dict) -> str:
+        prompt = f"""As an AI assistant specializing in {domain}, analyze these metrics and provide key insights:
+
+Metrics:
+{chr(10).join(f"- {k}: {v}" for k, v in metrics.items())}
+
+Provide 3-5 key insights that:
+1. Highlight important trends or patterns
+2. Identify potential opportunities or risks
+3. Suggest actionable recommendations
+
+Insights:"""
+
+        try:
+            response = self.model.generate_content(prompt)
+            return response.text
+        except Exception as e:
+            print(f"Error generating insights: {e}")
+            return "Unable to generate insights at this time." 

client/src/App.css

@@ -5,6 +5,33 @@
   flex-direction: column;
 }
 
+.floating-logo {
+  position: fixed;
+  top: 20px;
+  left: 50%;
+  transform: translateX(-50%);
+  z-index: 1000;
+  animation: float 3s ease-in-out infinite;
+}
+
+.floating-logo img {
+  width: 150px;
+  height: auto;
+  filter: drop-shadow(0 0 10px rgba(0, 0, 0, 0.3));
+}
+
+@keyframes float {
+  0% {
+    transform: translateX(-50%) translateY(0px);
+  }
+  50% {
+    transform: translateX(-50%) translateY(-10px);
+  }
+  100% {
+    transform: translateX(-50%) translateY(0px);
+  }
+}
+
 .content {
   flex: 1;
 }
@@ -19,6 +46,7 @@
   color: white;
   padding: 2rem;
   text-align: center;
+  padding-top: 120px;
 }
 
 .App-header h1 {
@@ -77,6 +105,14 @@
 }
 
 @media (max-width: 768px) {
+  .floating-logo img {
+    width: 120px;
+  }
+
+  .App-header {
+    padding-top: 100px;
+  }
+
   .App-header h1 {
     font-size: 3rem;
   }

client/src/App.js

@@ -3,6 +3,7 @@ import { BrowserRouter as Router, Routes, Route } from 'react-router-dom';
 import Navbar from './components/Navbar';
 import Footer from './components/Footer';
 import DomainPage from './pages/DomainPage';
+import logo from './logo.png';
 import './App.css';
 
 // Icons (you can replace these with actual icons)
@@ -26,6 +27,9 @@ function App() {
   return (
     <Router>
       <div className="App">
+        <div className="floating-logo">
+          <img src={logo} alt="M.A.D.H.A.V.A. Logo" />
+        </div>
         <Navbar />
         <div className="content">
           <Routes>