Ved0715/Super-MCP-Server

# 1. Clone the repository
git clone https://github.com/Ved0715/mcp-server-reserch-assistent.git
cd mcp-server-reserch-assistent

# 2. Run automated setup (creates virtual environment, installs dependencies)
python run.py

# 3. Follow the prompts to configure environment

# 1. Clone repository
git clone https://github.com/Ved0715/mcp-server-reserch-assistent.git
cd mcp-server-reserch-assistent

# 2. Create virtual environment
python -m venv perfect_env
source perfect_env/bin/activate  # On Windows: perfect_env\Scripts\activate

# 3. Install dependencies
pip install -r requirements.txt

# 4. Download required NLTK data
python -c "import nltk; nltk.download('punkt')"

# Start the HTTP MCP server
python start_mcp_server.py --host localhost --port 3001

# Server will be available at: http://localhost:3001
# Health check: curl http://localhost:3001/health

# Activate virtual environment (if not already activated)
source perfect_env/bin/activate  # Windows: perfect_env\Scripts\activate

# Launch web interface
streamlit run perfect_app.py --server.port 8502

# Start traditional MCP server
python perfect_mcp_server.py

# Use the launcher for guided setup
python run.py
# Choose option 1 for web interface, option 2 for MCP server, or option 3 for HTTP server

{
  "tool": "advanced_search_web",
  "arguments": {
    "query": "machine learning in healthcare 2024",
    "search_type": "scholar",           // Options: "web", "scholar", "news", "images"
    "num_results": 10,
    "location": "United States",
    "time_period": "year",             // Options: "all", "year", "month", "week", "day"
    "enhance_results": true            // AI enhancement with themes/gaps analysis
  }
}

{
  "tool": "process_research_paper",
  "arguments": {
    "file_content": "base64_encoded_pdf_content",
    "file_name": "research_paper.pdf",
    "paper_id": "paper_001",
    "enable_research_analysis": true,
    "enable_vector_storage": true,
    "analysis_depth": "comprehensive"    // Options: "basic", "standard", "comprehensive"
  }
}

{
  "tool": "create_perfect_presentation",
  "arguments": {
    "paper_id": "paper_001",
    "user_prompt": "Focus on methodology and statistical results for academic conference presentation",
    "title": "Research Findings Presentation",
    "author": "Your Name",
    "theme": "academic_professional",     // Options: "academic_professional", "research_modern", "executive_clean"
    "slide_count": 12,
    "audience_type": "academic",          // Options: "academic", "business", "general", "executive"
    "include_search_results": false,
    "search_query": "related research context"
  }
}

{
  "tool": "research_intelligence_analysis",
  "arguments": {
    "paper_id": "paper_001",
    "analysis_types": ["methodology", "contributions", "quality", "citations", "statistical", "limitations"],
    "provide_recommendations": true
  }
}

{
  "tool": "semantic_paper_search",
  "arguments": {
    "query": "statistical significance and p-values methodology",
    "paper_id": "paper_001",              // Optional: search specific paper
    "search_type": "results",             // Options: "general", "methodology", "results", "discussion", "conclusion"
    "max_results": 10,
    "similarity_threshold": 0.7
  }
}

{
  "tool": "compare_research_papers",
  "arguments": {
    "paper_ids": ["paper_001", "paper_002", "paper_003"],
    "comparison_aspects": ["methodology", "findings", "contributions", "limitations", "citations", "quality"],
    "generate_summary": true
  }
}

{
  "tool": "generate_research_insights",
  "arguments": {
    "paper_id": "paper_001",
    "focus_area": "future_research",      // Options: "methodology_improvement", "future_research", "practical_applications", "theoretical_implications"
    "insight_depth": "detailed",          // Options: "overview", "detailed", "comprehensive"
    "include_citations": true
  }
}

{
  "tool": "export_research_summary",
  "arguments": {
    "paper_id": "paper_001",
    "export_format": "markdown",          // Options: "markdown", "json", "academic_report"
    "include_analysis": true,
    "include_presentation_ready": false
  }
}

{
  "tool": "list_processed_papers",
  "arguments": {
    "include_stats": true,
    "sort_by": "quality_score"           // Options: "name", "date", "quality_score"
  }
}

{
  "tool": "system_status",
  "arguments": {
    "include_config": false,
    "run_health_check": true
  }
}

# 1. Start web interface
streamlit run perfect_app.py --server.port 8502

# 2. Upload research paper (Tab 1: Upload & Process)
# 3. Review analysis results with quality scoring
# 4. Query specific sections (Tab 2: Query & Q&A)
# 5. Generate conference presentation (Tab 3: Generate PPT)

// 1. Process multiple papers
{"tool": "process_research_paper", "arguments": {"file_content": "...", "paper_id": "paper_001"}}
{"tool": "process_research_paper", "arguments": {"file_content": "...", "paper_id": "paper_002"}}

// 2. Compare methodologies
{"tool": "compare_research_papers", "arguments": {"paper_ids": ["paper_001", "paper_002"], "comparison_aspects": ["methodology", "findings"]}}

// 3. Export comprehensive summary
{"tool": "export_research_summary", "arguments": {"paper_id": "paper_001", "export_format": "academic_report"}}

// 1. Search for industry research
{"tool": "advanced_search_web", "arguments": {"query": "AI in healthcare market trends 2024", "search_type": "web", "enhance_results": true}}

// 2. Process relevant papers
{"tool": "process_research_paper", "arguments": {"file_content": "...", "paper_id": "market_analysis"}}

// 3. Create executive presentation
{"tool": "create_perfect_presentation", "arguments": {"paper_id": "market_analysis", "theme": "executive_clean", "audience_type": "business"}}

# config.py - Key cost-optimized settings
LLM_MODEL = "gpt-4o-mini"                    # 85% cheaper than GPT-4
EMBEDDING_MODEL = "text-embedding-3-large"   # High quality, reasonable cost
CHUNK_SIZE = 1000                            # Optimal for accuracy/cost balance
CHUNK_OVERLAP = 200                          # Good context preservation
PPT_MAX_SLIDES = 25                          # Reasonable presentation length

# Research Intelligence Settings
ENABLE_RESEARCH_INTELLIGENCE = True          # AI analysis engine
ENABLE_STATISTICAL_EXTRACTION = True         # P-value and correlation detection
ENABLE_CITATION_ANALYSIS = True              # Reference pattern analysis
ENABLE_METHODOLOGY_ANALYSIS = True           # Research design assessment

# Vector Storage Settings
VECTOR_SIMILARITY_THRESHOLD = 0.7            # Relevance threshold for semantic search
MAX_RETRIEVAL_RESULTS = 20                   # Search result limit
ENABLE_VECTOR_STORAGE = True                 # Pinecone integration

# Presentation Settings
ENABLE_ACADEMIC_FORMATTING = True            # Scholar-appropriate styling
ENABLE_AUTO_CITATIONS = True                 # Automatic reference integration
ENABLE_VISUAL_ENHANCEMENTS = True            # Professional graphics and layouts

# Navigate to MCP server directory
cd /path/to/mcp-server-reserch-assistent

# Start the standalone HTTP server
python start_mcp_server.py --host localhost --port 3001

# your_existing_fastapi_app.py
from fastapi import FastAPI
import sys
from pathlib import Path

# Add MCP integration path
mcp_dir = Path("/path/to/mcp-server-reserch-assistent")
sys.path.insert(0, str(mcp_dir))

# Import MCP routes
from api_integration.fastapi_routes import router as mcp_router, cleanup_mcp_client

# Your existing FastAPI app
app = FastAPI()

# Your existing routes
@app.get("/")
def read_root():
    return {"message": "Your existing API"}

# Add MCP routes (ONE LINE!)
app.include_router(mcp_router)

# Add cleanup on shutdown (ONE LINE!)
@app.on_event("shutdown")
async def shutdown_event():
    await cleanup_mcp_client()

# Start your FastAPI server
uvicorn your_app:app --host localhost --port 8000

# Test health check
curl http://localhost:8000/api/v1/mcp/health

# Test web search
curl -X POST http://localhost:8000/api/v1/mcp/search/web \
  -H "Content-Type: application/json" \
  -d '{"query": "AI research", "search_type": "scholar", "num_results": 5}'

GET /api/v1/mcp/health          # Check MCP server health
GET /api/v1/mcp/tools           # List available tools  
GET /api/v1/mcp/status          # System status

POST /api/v1/mcp/papers/upload          # Upload and process PDFs
GET /api/v1/mcp/papers/{paper_id}       # Get paper information

POST /api/v1/mcp/search/web             # Web search (Google, Scholar, News)
POST /api/v1/mcp/search/semantic        # AI search within papers

POST /api/v1/mcp/presentations/generate                    # Generate PowerPoint presentations
GET /api/v1/mcp/presentations/{filename}/download         # Download presentations

POST /api/v1/mcp/analysis/research      # Research intelligence analysis
POST /api/v1/mcp/insights/generate      # Generate research insights

curl -X POST http://localhost:8000/api/v1/mcp/papers/upload \
  -F "file=@research_paper.pdf" \
  -F "paper_id=my_paper_001" \
  -F "enable_research_analysis=true" \
  -F "enable_vector_storage=true" \
  -F "analysis_depth=comprehensive"

curl -X POST http://localhost:8000/api/v1/mcp/search/web \
  -H "Content-Type: application/json" \
  -d '{
    "query": "machine learning healthcare applications",
    "search_type": "scholar",
    "num_results": 10,
    "enhance_results": true
  }'

curl -X POST http://localhost:8000/api/v1/mcp/presentations/generate \
  -H "Content-Type: application/json" \
  -d '{
    "paper_id": "my_paper_001",
    "user_prompt": "Focus on methodology and results for medical professionals",
    "title": "Research Findings Presentation",
    "theme": "academic_professional",
    "slide_count": 15,
    "audience_type": "academic"
  }'

curl -X POST http://localhost:8000/api/v1/mcp/search/semantic \
  -H "Content-Type: application/json" \
  -d '{
    "query": "What were the statistical results and p-values?",
    "paper_id": "my_paper_001",
    "max_results": 5,
    "similarity_threshold": 0.7
  }'

# OpenAI Configuration
OPENAI_API_KEY=your_openai_api_key_here

# SerpAPI Configuration (for web search)
SERPAPI_API_KEY=your_serpapi_key_here

# Pinecone Configuration (for vector storage)
PINECONE_API_KEY=your_pinecone_api_key_here
PINECONE_ENVIRONMENT=your_pinecone_environment

# LlamaParse Configuration (for advanced PDF parsing)
LLAMA_CLOUD_API_KEY=your_llama_cloud_api_key_here

# MCP Server Configuration
MCP_SERVER_HOST=localhost
MCP_SERVER_PORT=3001

# Custom host and port
python start_mcp_server.py --host 0.0.0.0 --port 3002

# Enable debug logging
python start_mcp_server.py --debug

# Help
python start_mcp_server.py --help

from fastapi import FastAPI, UploadFile, File, HTTPException, BackgroundTasks
from pydantic import BaseModel
from typing import List, Optional, Dict, Any
import base64
import asyncio
import uuid
from datetime import datetime

# Import MCP components
from perfect_mcp_server import PerfectMCPServer
from config import AdvancedConfig

app = FastAPI(title="Research Intelligence API", version="1.0.0")

# Initialize MCP server
mcp_server = PerfectMCPServer()

# Pydantic models
class PaperProcessRequest(BaseModel):
    file_name: str
    paper_id: str
    enable_research_analysis: bool = True
    enable_vector_storage: bool = True
    analysis_depth: str = "comprehensive"

class PresentationRequest(BaseModel):
    paper_id: str
    user_prompt: str
    title: Optional[str] = None
    author: str = "AI Research Assistant"
    theme: str = "academic_professional"
    slide_count: int = 12
    audience_type: str = "academic"
    include_search_results: bool = False
    search_query: Optional[str] = None

class SearchRequest(BaseModel):
    query: str
    search_type: str = "web"
    num_results: int = 10
    location: str = "United States"
    time_period: str = "all"
    enhance_results: bool = True

class SemanticSearchRequest(BaseModel):
    query: str
    paper_id: Optional[str] = None
    search_type: str = "general"
    max_results: int = 10
    similarity_threshold: float = 0.7

# API Endpoints

@app.post("/api/research/process-paper")
async def process_research_paper(
    file: UploadFile = File(...),
    request: PaperProcessRequest = None
):
    """Process a research paper PDF with advanced analysis"""
    try:
        # Read file content
        content = await file.read()
        file_base64 = base64.b64encode(content).decode('utf-8')
        
        # Generate paper ID if not provided
        paper_id = request.paper_id if request else str(uuid.uuid4())
        
        # Process using MCP server
        result = await mcp_server._handle_process_paper(
            file_content=file_base64,
            file_name=file.filename,
            paper_id=paper_id,
            enable_research_analysis=request.enable_research_analysis if request else True,
            enable_vector_storage=request.enable_vector_storage if request else True,
            analysis_depth=request.analysis_depth if request else "comprehensive"
        )
        
        return {
            "success": True,
            "paper_id": paper_id,
            "file_name": file.filename,
            "result": result[0].text if result else "Processing completed"
        }
        
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Processing failed: {str(e)}")

@app.post("/api/research/create-presentation")
async def create_presentation(request: PresentationRequest):
    """Create a perfect research presentation"""
    try:
        result = await mcp_server._handle_create_presentation(
            paper_id=request.paper_id,
            user_prompt=request.user_prompt,
            title=request.title,
            author=request.author,
            theme=request.theme,
            slide_count=request.slide_count,
            audience_type=request.audience_type,
            include_search_results=request.include_search_results,
            search_query=request.search_query
        )
        
        return {
            "success": True,
            "result": result[0].text if result else "Presentation created"
        }
        
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Presentation creation failed: {str(e)}")

@app.post("/api/research/search")
async def advanced_search(request: SearchRequest):
    """Perform advanced web search with AI enhancement"""
    try:
        result = await mcp_server._handle_advanced_search(
            query=request.query,
            search_type=request.search_type,
            num_results=request.num_results,
            location=request.location,
            time_period=request.time_period,
            enhance_results=request.enhance_results
        )
        
        return {
            "success": True,
            "result": result[0].text if result else "Search completed"
        }
        
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Search failed: {str(e)}")

@app.post("/api/research/semantic-search")
async def semantic_search(request: SemanticSearchRequest):
    """Perform semantic search within processed papers"""
    try:
        result = await mcp_server._handle_semantic_search(
            query=request.query,
            paper_id=request.paper_id,
            search_type=request.search_type,
            max_results=request.max_results,
            similarity_threshold=request.similarity_threshold
        )
        
        return {
            "success": True,
            "result": result[0].text if result else "Search completed"
        }
        
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Semantic search failed: {str(e)}")

@app.get("/api/research/papers")
async def list_papers(include_stats: bool = True, sort_by: str = "date"):
    """List all processed research papers"""
    try:
        result = await mcp_server._handle_list_papers(
            include_stats=include_stats,
            sort_by=sort_by
        )
        
        return {
            "success": True,
            "result": result[0].text if result else "No papers found"
        }
        
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Failed to list papers: {str(e)}")

@app.get("/api/research/status")
async def system_status(include_config: bool = False):
    """Get comprehensive system status"""
    try:
        result = await mcp_server._handle_system_status(
            include_config=include_config,
            run_health_check=True
        )
        
        return {
            "success": True,
            "result": result[0].text if result else "System status retrieved"
        }
        
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Status check failed: {str(e)}")

@app.post("/api/research/analysis/{paper_id}")
async def research_analysis(
    paper_id: str,
    analysis_types: List[str] = ["methodology", "contributions", "quality"],
    provide_recommendations: bool = True
):
    """Perform comprehensive research intelligence analysis"""
    try:
        result = await mcp_server._handle_research_analysis(
            paper_id=paper_id,
            analysis_types=analysis_types,
            provide_recommendations=provide_recommendations
        )
        
        return {
            "success": True,
            "paper_id": paper_id,
            "result": result[0].text if result else "Analysis completed"
        }
        
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Analysis failed: {str(e)}")

# Health check endpoint
@app.get("/health")
async def health_check():
    return {"status": "healthy", "timestamp": datetime.now().isoformat()}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

# Copy environment configuration
cp .env.template your_fastapi_project/.env
# Edit .env with your API keys (same as above)

# Navigate to your FastAPI project
cd your_fastapi_project

# Install dependencies
pip install -r mcp_requirements.txt

# Run FastAPI server
uvicorn research_service:app --host 0.0.0.0 --port 8000 --reload

// research-api.js
const API_BASE = 'http://localhost:8000/api/research';

export const ResearchAPI = {
  // Process research paper
  async processPaper(file, paperData) {
    const formData = new FormData();
    formData.append('file', file);
    
    const response = await fetch(`${API_BASE}/process-paper`, {
      method: 'POST',
      body: formData,
      headers: {
        'Content-Type': 'application/json',
        ...paperData && { 'X-Paper-Data': JSON.stringify(paperData) }
      }
    });
    
    return response.json();
  },

  // Create presentation
  async createPresentation(presentationData) {
    const response = await fetch(`${API_BASE}/create-presentation`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(presentationData)
    });
    
    return response.json();
  },

  // Advanced search
  async search(searchData) {
    const response = await fetch(`${API_BASE}/search`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(searchData)
    });
    
    return response.json();
  },

  // Semantic search
  async semanticSearch(searchData) {
    const response = await fetch(`${API_BASE}/semantic-search`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(searchData)
    });
    
    return response.json();
  }
};

// ResearchDashboard.jsx
import React, { useState } from 'react';
import { ResearchAPI } from './research-api';

export const ResearchDashboard = () => {
  const [papers, setPapers] = useState([]);
  const [loading, setLoading] = useState(false);

  const handlePaperUpload = async (file) => {
    setLoading(true);
    try {
      const result = await ResearchAPI.processPaper(file, {
        paper_id: `paper_${Date.now()}`,
        enable_research_analysis: true,
        analysis_depth: 'comprehensive'
      });
      
      if (result.success) {
        setPapers(prev => [...prev, result]);
        alert('Paper processed successfully!');
      }
    } catch (error) {
      console.error('Upload failed:', error);
    } finally {
      setLoading(false);
    }
  };

  const handleCreatePresentation = async (paperId, prompt) => {
    setLoading(true);
    try {
      const result = await ResearchAPI.createPresentation({
        paper_id: paperId,
        user_prompt: prompt,
        theme: 'academic_professional',
        slide_count: 12,
        audience_type: 'academic'
      });
      
      if (result.success) {
        alert('Presentation created successfully!');
      }
    } catch (error) {
      console.error('Presentation creation failed:', error);
    } finally {
      setLoading(false);
    }
  };

  return (
    <div className="research-dashboard">
      <h1>Research Intelligence Dashboard</h1>
      
      {/* File Upload */}
      <div className="upload-section">
        <input
          type="file"
          accept=".pdf"
          onChange={(e) => handlePaperUpload(e.target.files[0])}
          disabled={loading}
        />
        {loading && <p>Processing...</p>}
      </div>

      {/* Papers List */}
      <div className="papers-list">
        {papers.map((paper, idx) => (
          <div key={idx} className="paper-card">
            <h3>{paper.file_name}</h3>
            <p>Paper ID: {paper.paper_id}</p>
            <button 
              onClick={() => handleCreatePresentation(
                paper.paper_id, 
                "Create a comprehensive presentation focusing on methodology and key findings"
              )}
            >
              Create Presentation
            </button>
          </div>
        ))}
      </div>
    </div>
  );
};

# For long-running tasks
from fastapi import BackgroundTasks

@app.post("/api/research/process-paper-async")
async def process_paper_async(
    background_tasks: BackgroundTasks,
    file: UploadFile = File(...),
    request: PaperProcessRequest = None
):
    """Process paper asynchronously"""
    task_id = str(uuid.uuid4())
    
    # Add to background tasks
    background_tasks.add_task(
        process_paper_background,
        task_id,
        file,
        request
    )
    
    return {"task_id": task_id, "status": "processing"}

async def process_paper_background(task_id: str, file: UploadFile, request: PaperProcessRequest):
    """Background task for paper processing"""
    # Implementation here
    pass

from fastapi import WebSocket

@app.websocket("/ws/research/{client_id}")
async def websocket_endpoint(websocket: WebSocket, client_id: str):
    await websocket.accept()
    
    try:
        while True:
            data = await websocket.receive_json()
            
            if data['type'] == 'process_paper':
                # Process and send updates
                await websocket.send_json({
                    "type": "progress",
                    "message": "Processing PDF...",
                    "progress": 25
                })
                
                # Continue processing...
                
    except Exception as e:
        await websocket.send_json({
            "type": "error",
            "message": str(e)
        })

# 1. Start MCP server
python start_mcp_server.py --host localhost --port 3001

# 2. Test endpoints
curl http://localhost:3001/health
curl -X POST http://localhost:3001/mcp/call -H "Content-Type: application/json" -d '{"tool": "advanced_search_web", "arguments": {"query": "AI research"}}'

# 1. Add to your FastAPI app
from api_integration.fastapi_routes import router as mcp_router, cleanup_mcp_client

app.include_router(mcp_router)

@app.on_event("shutdown")
async def shutdown_event():
    await cleanup_mcp_client()

# 2. Your API now has 11 new research endpoints!

# Issue: LlamaParse API key missing
⚠️ LLAMA_PARSE_API_KEY not set - using fallback PDF parsing

# Solution: Add LlamaParse API key to .env (optional but recommended)
LLAMA_PARSE_API_KEY=your_llamaparse_api_key_here

# Issue: Vector dimension mismatch
❌ Vector dimension 1536 does not match the dimension of the index 3072

# Solution: Ensure embedding model matches index dimensions
# In .env file:
EMBEDDING_MODEL=text-embedding-3-large
EMBEDDING_DIMENSIONS=3072

# Issue: Rate limiting or quota exceeded
❌ Rate limit exceeded for requests

# Solutions:
# 1. Reduce batch sizes in config.py
# 2. Add delays between requests
# 3. Upgrade OpenAI plan
# 4. Use gpt-4o-mini for cost optimization

# Issue: SerpAPI quota exceeded
❌ SerpAPI monthly limit reached

# Solutions:
# 1. SerpAPI offers 100 free searches/month
# 2. Upgrade to paid plan for more searches
# 3. Implement search result caching

# Issue: Large PDF processing fails
❌ Memory error processing large documents

# Solutions:
# 1. Reduce CHUNK_SIZE in config.py
# 2. Process papers individually
# 3. Increase system RAM
# 4. Use cloud processing for large files

# Issue: Missing dependencies
❌ ModuleNotFoundError: No module named 'nltk'

# Solution: Ensure all dependencies are installed
pip install -r requirements.txt
python -c "import nltk; nltk.download('punkt')"

# Run comprehensive system check
python run.py

# Check API connectivity
python -c "from config import AdvancedConfig; print(AdvancedConfig().validate_config())"

# Test Pinecone connection
python -c "from vector_storage import AdvancedVectorStorage; vs = AdvancedVectorStorage(config); print('Connected!')"

# Verify Streamlit installation
streamlit --version

# Clone for development
git clone https://github.com/Ved0715/mcp-server-reserch-assistent.git
cd mcp-server-reserch-assistent

# Create development environment
python -m venv dev_env
source dev_env/bin/activate  # Windows: dev_env\Scripts\activate

# Install development dependencies
pip install -r requirements.txt
pip install pytest black flake8 mypy

# Run tests
pytest

# Code formatting
black *.py
flake8 *.py

# Get started in 3 simple commands
git clone https://github.com/Ved0715/mcp-server-reserch-assistent.git
cd mcp-server-reserch-assistent
python run.py