Upload 6 files

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Gemini MCP Server
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

init_db.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+"""
+Database initialization script for Gemini MCP Server
+Run this script to create all database tables
+"""
+
+from database import engine, Base
+from models import ChatMessage, User, Tenant
+import os
+
+def init_database():
+    """Initialize the database with all tables"""
+    print("🚀 Initializing database...")
+    
+    try:
+        # Create all tables
+        Base.metadata.create_all(bind=engine)
+        print("✅ Database tables created successfully!")
+        
+        # Show created tables
+        print("\n📊 Created tables:")
+        for table_name in Base.metadata.tables.keys():
+            print(f"  - {table_name}")
+            
+        print(f"\n💾 Database location: {os.getenv('DATABASE_URL', 'sqlite:///./mcp_server.db')}")
+        print("🎉 Database initialization complete!")
+        
+    except Exception as e:
+        print(f"❌ Error initializing database: {str(e)}")
+        return False
+        
+    return True
+
+if __name__ == "__main__":
+    init_database() 

mcp_config.py

@@ -0,0 +1,27 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class MCPSettings:
+    # Server configuration
+    SERVER_NAME = os.getenv("SERVER_NAME", "Gemini MCP Server")
+    SERVER_VERSION = os.getenv("SERVER_VERSION", "2.0.0")
+    
+    # Model configuration
+    MODEL_NAME = "gemini-1.5-flash"
+    MODEL_VERSION = "1.5"
+    CONTEXT_PROVIDER = "internal"
+    
+    # Rate limiting
+    RATE_LIMIT_REQUESTS = int(os.getenv("RATE_LIMIT_REQUESTS", "100"))
+    RATE_LIMIT_PERIOD = int(os.getenv("RATE_LIMIT_PERIOD", "60"))
+    
+    # Context settings
+    MAX_CONTEXT_RESULTS = int(os.getenv("MAX_CONTEXT_RESULTS", "10"))
+    
+    # Debug mode
+    DEBUG = os.getenv("DEBUG", "False").lower() == "true"
+
+# Create global settings instance
+mcp_settings = MCPSettings()

middleware.py

@@ -0,0 +1,63 @@
+import time
+from typing import Dict
+from fastapi import Request, Response, HTTPException
+from fastapi.responses import JSONResponse
+from mcp_config import mcp_settings
+
+# Simple in-memory rate limiting (use Redis in production)
+request_counts: Dict[str, Dict[str, int]] = {}
+
+async def rate_limit_middleware(request: Request, call_next):
+    """Rate limiting middleware"""
+    client_ip = request.client.host if request.client else "unknown"
+    current_time = int(time.time())
+    window_start = current_time // mcp_settings.RATE_LIMIT_PERIOD * mcp_settings.RATE_LIMIT_PERIOD
+    
+    # Initialize client data if not exists
+    if client_ip not in request_counts:
+        request_counts[client_ip] = {}
+    
+    # Clean old windows
+    for window in list(request_counts[client_ip].keys()):
+        if window < window_start:
+            del request_counts[client_ip][window]
+    
+    # Check current window
+    if window_start not in request_counts[client_ip]:
+        request_counts[client_ip][window_start] = 0
+    
+    # Check rate limit
+    if request_counts[client_ip][window_start] >= mcp_settings.RATE_LIMIT_REQUESTS:
+        return JSONResponse(
+            status_code=429,
+            content={
+                "code": "RATE_LIMIT_EXCEEDED",
+                "message": f"Rate limit exceeded. Max {mcp_settings.RATE_LIMIT_REQUESTS} requests per {mcp_settings.RATE_LIMIT_PERIOD} seconds.",
+                "details": {
+                    "retry_after": mcp_settings.RATE_LIMIT_PERIOD - (current_time % mcp_settings.RATE_LIMIT_PERIOD)
+                }
+            }
+        )
+    
+    # Increment counter
+    request_counts[client_ip][window_start] += 1
+    
+    response = await call_next(request)
+    return response
+
+async def validate_mcp_request(request: Request, call_next):
+    """Validate MCP request format"""
+    try:
+        response = await call_next(request)
+        return response
+    except Exception as e:
+        if mcp_settings.DEBUG:
+            print(f"Request validation error: {str(e)}")
+        return JSONResponse(
+            status_code=500,
+            content={
+                "code": "INTERNAL_ERROR",
+                "message": "Internal server error",
+                "details": {"timestamp": time.time()}
+            }
+        ) 

models.py

@@ -0,0 +1,36 @@
+from sqlalchemy import Column, Integer, String, Text, DateTime, Boolean
+from sqlalchemy.sql import func
+from database import Base
+
+class ChatMessage(Base):
+    __tablename__ = "chat_messages"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, nullable=False)
+    message = Column(Text, nullable=False)
+    response = Column(Text, nullable=False)
+    context = Column(Text)  # JSON string
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), onupdate=func.now())
+
+class User(Base):
+    __tablename__ = "users"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    email = Column(String(255), unique=True, index=True, nullable=False)
+    name = Column(String(255), nullable=False)
+    hashed_password = Column(String(255), nullable=False)
+    is_active = Column(Boolean, default=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), onupdate=func.now())
+
+class Tenant(Base):
+    __tablename__ = "tenants"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String(255), nullable=False)
+    domain = Column(String(255), unique=True, index=True)
+    owner_id = Column(Integer, nullable=False)  # Reference to User
+    is_active = Column(Boolean, default=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), onupdate=func.now()) 

test_api.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+"""
+Simple test script for Gemini MCP Server API
+Run this after starting the server to verify it's working
+"""
+
+import requests
+import json
+import time
+
+# Server configuration
+BASE_URL = "http://localhost:8000"
+AUTH_TOKEN = "test-token"  # Replace with actual token
+
+def test_endpoint(endpoint, method="GET", data=None):
+    """Test a single endpoint"""
+    url = f"{BASE_URL}{endpoint}"
+    headers = {
+        "Content-Type": "application/json",
+        "x-mcp-auth": AUTH_TOKEN
+    }
+    
+    try:
+        if method == "POST":
+            response = requests.post(url, headers=headers, json=data, timeout=30)
+        else:
+            response = requests.get(url, timeout=10)
+            
+        print(f"✅ {method} {endpoint}: {response.status_code}")
+        
+        if response.status_code == 200:
+            result = response.json()
+            print(f"   Response: {json.dumps(result, indent=2)[:200]}...")
+        else:
+            print(f"   Error: {response.text}")
+            
+        return response.status_code == 200
+        
+    except requests.exceptions.RequestException as e:
+        print(f"❌ {method} {endpoint}: Connection error - {str(e)}")
+        return False
+
+def main():
+    """Run all tests"""
+    print("🧪 Testing Gemini MCP Server API...")
+    print(f"🌐 Server: {BASE_URL}")
+    print("-" * 50)
+    
+    tests = [
+        ("Root endpoint", "/", "GET"),
+        ("Health check", "/mcp/health", "GET"),
+        ("Version info", "/mcp/version", "GET"),
+        ("Capabilities", "/mcp/capabilities", "GET"),
+    ]
+    
+    # Test basic endpoints
+    for name, endpoint, method in tests:
+        print(f"\n🔍 Testing {name}...")
+        test_endpoint(endpoint, method)
+    
+    # Test process endpoint
+    print(f"\n🔍 Testing MCP Process...")
+    test_data = {
+        "query": "Hello, can you help me with my account?",
+        "user_id": "test_user_123",
+        "priority": "normal",
+        "mcp_version": "1.0"
+    }
+    test_endpoint("/mcp/process", "POST", test_data)
+    
+    # Test batch endpoint
+    print(f"\n🔍 Testing MCP Batch...")
+    batch_data = {
+        "queries": ["How do I reset my password?", "What are your business hours?"],
+        "user_id": "test_user_123",
+        "mcp_version": "1.0"
+    }
+    test_endpoint("/mcp/batch", "POST", batch_data)
+    
+    print("\n🎉 API testing complete!")
+
+if __name__ == "__main__":
+    main()