Initial commit: AI Literature Review System

- Multi-agent review system with 3 specialized reviewers
- MarkItDown integration for PDF processing
- Semantic Scholar API integration for related papers
- OpenAI-compatible API support
- Gradio interface with progress tracking
- Sequential review processing

.env.example

@@ -0,0 +1,13 @@
+# OpenAI-compatible API Configuration
+OPENAI_API_KEY=your-api-key-here
+OPENAI_BASE_URL=https://api.openai.com/v1
+MODEL_NAME=gpt-4
+
+# Alternative configurations:
+# For Azure OpenAI:
+# OPENAI_BASE_URL=https://your-resource.openai.azure.com/
+# MODEL_NAME=your-deployment-name
+
+# For custom endpoints (e.g., LocalAI, vLLM, etc.):
+# OPENAI_BASE_URL=http://localhost:8000/v1
+# MODEL_NAME=your-model-name

.gitignore

@@ -0,0 +1,46 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+venv/
+ENV/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Gradio
+gradio_cached_examples/
+flagged/
+
+# Environment variables
+.env
+.env.local
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log

agents.py

@@ -0,0 +1,289 @@
+"""Multi-agent system for literature review using OpenAI-compatible API."""
+
+import json
+import re
+import os
+from typing import Any, Optional, Dict, Tuple
+from openai import OpenAI
+
+
+def extract_json_between_markers(llm_output: str) -> Optional[Dict[str, Any]]:
+    """Extracts JSON content from a string, typically an LLM output."""
+    json_pattern = r"```json(.*?)```"
+    matches = re.findall(json_pattern, llm_output, re.DOTALL)
+
+    if not matches:
+        json_pattern_fallback = r"\{[^{}]*\}"
+        matches = re.findall(json_pattern_fallback, llm_output, re.DOTALL)
+
+    for json_string in matches:
+        json_string = json_string.strip()
+        try:
+            parsed_json = json.loads(json_string)
+            return parsed_json
+        except json.JSONDecodeError:
+            try:
+                json_string_clean = "".join(
+                    char for char in json_string if ord(char) >= 32 and ord(char) != 127
+                )
+                parsed_json = json.loads(json_string_clean)
+                return parsed_json
+            except json.JSONDecodeError:
+                continue
+
+    return None
+
+
+def query_model(system_prompt: str, prompt: str, client: OpenAI, model: str) -> Optional[str]:
+    """Query the model with the given prompts using OpenAI-compatible API."""
+    try:
+        response = client.chat.completions.create(
+            model=model,
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": prompt}
+            ],
+            temperature=0.7,
+            max_tokens=4000
+        )
+        return response.choices[0].message.content
+    except Exception as e:
+        print(f"Error querying model: {e}")
+        return None
+
+
+def get_score(
+    paper_content: str,
+    reviewer_type: Optional[str] = None,
+    attempts: int = 3,
+    client: OpenAI = None,
+    model: str = None,
+) -> Tuple[Optional[float], str, bool]:
+    """Evaluates a research paper using an LLM reviewer."""
+
+    last_exception_message = ""
+    for attempt in range(attempts):
+        try:
+            template_instructions = """
+            Respond in the following format:
+
+            THOUGHT:
+            <THOUGHT>
+
+            REVIEW JSON:
+            ```json
+            <JSON>
+            ```
+
+            In <THOUGHT>, first briefly discuss your intuitions and reasoning for the evaluation.
+            Detail your high-level arguments, necessary choices and desired outcomes of the review.
+
+            In <JSON>, provide the review in JSON format with the following fields:
+            - "Summary": A summary of the paper content and its contributions.
+            - "Strengths": A list of strengths of the paper.
+            - "Weaknesses": A list of weaknesses of the paper.
+            - "Originality": A rating from 1 to 4 (low, medium, high, very high).
+            - "Quality": A rating from 1 to 4 (low, medium, high, very high).
+            - "Clarity": A rating from 1 to 4 (low, medium, high, very high).
+            - "Significance": A rating from 1 to 4 (low, medium, high, very high).
+            - "Questions": A set of clarifying questions to be answered by the paper authors.
+            - "Limitations": A set of limitations and potential negative societal impacts.
+            - "Ethical Concerns": A boolean value indicating whether there are ethical concerns.
+            - "Soundness": A rating from 1 to 4 (poor, fair, good, excellent).
+            - "Presentation": A rating from 1 to 4 (poor, fair, good, excellent).
+            - "Contribution": A rating from 1 to 4 (poor, fair, good, excellent).
+            - "Overall": A rating from 1 to 10 (very strong reject to award quality).
+            - "Confidence": A rating from 1 to 5 (low, medium, high, very high, absolute).
+            - "Decision": A decision that has to be one of: Accept, Reject.
+            """
+
+            neurips_form = """
+            ## Review Guidelines
+
+            Evaluate the paper across these dimensions:
+
+            1. **Originality**: Are the ideas novel? Is related work cited?
+            2. **Quality**: Is the work technically sound? Are claims well supported?
+            3. **Clarity**: Is the paper well-written and organized?
+            4. **Significance**: Are the results important? Will others build on this work?
+            5. **Soundness**: Rate the technical quality (1-4: poor, fair, good, excellent)
+            6. **Presentation**: Rate the writing quality (1-4: poor, fair, good, excellent)
+            7. **Contribution**: Rate the overall contribution (1-4: poor, fair, good, excellent)
+            8. **Overall Score**: Rate 1-10 where:
+               - 1-3: Reject
+               - 4-6: Borderline
+               - 7-8: Accept
+               - 9-10: Strong Accept
+
+            """ + template_instructions
+
+            if reviewer_type is None:
+                reviewer_type = ""
+
+            sys_prompt = (
+                f"You are an AI researcher reviewing an academic paper. "
+                f"Be critical and thorough in your assessment. {reviewer_type}\n"
+            ) + neurips_form
+
+            prompt = f"Review the following paper:\n\n{paper_content}\n\n"
+
+            review_output = query_model(
+                system_prompt=sys_prompt,
+                prompt=prompt,
+                client=client,
+                model=model,
+            )
+
+            if review_output is None:
+                raise ValueError("LLM query returned None.")
+
+            review_json = extract_json_between_markers(review_output)
+
+            if review_json is None:
+                raise ValueError("Could not extract JSON review from LLM output.")
+
+            required_keys = [
+                "Overall", "Soundness", "Confidence", "Contribution",
+                "Presentation", "Clarity", "Originality", "Quality", "Significance",
+            ]
+
+            for key in required_keys:
+                if key not in review_json:
+                    raise KeyError(f"Missing key '{key}' in review JSON.")
+
+            # Calculate weighted score
+            overall = int(review_json["Overall"]) / 10.0
+            soundness = int(review_json["Soundness"]) / 4.0
+            confidence = int(review_json["Confidence"]) / 5.0
+            contribution = int(review_json["Contribution"]) / 4.0
+            presentation = int(review_json["Presentation"]) / 4.0
+            clarity = int(review_json["Clarity"]) / 4.0
+            originality = int(review_json["Originality"]) / 4.0
+            quality = int(review_json["Quality"]) / 4.0
+            significance = int(review_json["Significance"]) / 4.0
+
+            weights = {
+                "clarity": 0.1,
+                "quality": 0.1,
+                "overall": 1.0,
+                "soundness": 0.1,
+                "confidence": 0.1,
+                "originality": 0.1,
+                "significance": 0.1,
+                "contribution": 0.4,
+                "presentation": 0.2,
+            }
+
+            max_score = sum(weights.values())
+
+            performance = (
+                weights["soundness"] * soundness +
+                weights["presentation"] * presentation +
+                weights["confidence"] * confidence +
+                weights["contribution"] * contribution +
+                weights["overall"] * overall +
+                weights["originality"] * originality +
+                weights["significance"] * significance +
+                weights["clarity"] * clarity +
+                weights["quality"] * quality
+            ) / max_score * 10.0
+
+            return (
+                performance,
+                f"Performance Score: {performance:.2f}/10\n\n{review_output}",
+                True,
+            )
+
+        except Exception as e:
+            print(f"Error in get_score (attempt {attempt + 1}/{attempts}): {e}")
+            last_exception_message = str(e)
+
+    return (
+        None,
+        f"Failed to get score after {attempts} attempts. Last error: {last_exception_message}",
+        False,
+    )
+
+
+class ReviewerAgent:
+    """Agent that simulates a single reviewer with specific persona."""
+
+    def __init__(self, client: OpenAI, model: str, persona: str, name: str):
+        self.client = client
+        self.model = model
+        self.persona = persona
+        self.name = name
+
+    def review_paper(self, paper_content: str) -> Dict[str, Any]:
+        """Generate review for the paper."""
+        score, review_text, success = get_score(
+            paper_content=paper_content,
+            reviewer_type=self.persona,
+            client=self.client,
+            model=self.model,
+        )
+
+        return {
+            "reviewer": self.name,
+            "score": score,
+            "review": review_text,
+            "success": success
+        }
+
+
+class MultiReviewerSystem:
+    """System that coordinates multiple reviewer agents."""
+
+    def __init__(self, api_key: str, base_url: str, model: str):
+        self.client = OpenAI(api_key=api_key, base_url=base_url)
+        self.model = model
+
+        self.reviewers = [
+            ReviewerAgent(
+                client=self.client,
+                model=self.model,
+                persona="You focus on experimental rigor and expect well-designed experiments with clear insights.",
+                name="Reviewer 1: Experimentalist"
+            ),
+            ReviewerAgent(
+                client=self.client,
+                model=self.model,
+                persona="You look for impactful ideas that would advance the field significantly.",
+                name="Reviewer 2: Impactist"
+            ),
+            ReviewerAgent(
+                client=self.client,
+                model=self.model,
+                persona="You seek novel ideas that have not been proposed before and creative approaches.",
+                name="Reviewer 3: Novelty Seeker"
+            )
+        ]
+
+    def review_paper_sequential(self, paper_content: str, progress_callback=None) -> Dict[str, Any]:
+        """Generate reviews from multiple reviewers sequentially."""
+        reviews = []
+        total_score = 0
+        successful_reviews = 0
+
+        for i, reviewer in enumerate(self.reviewers):
+            if progress_callback:
+                progress_callback(i / len(self.reviewers), f"Reviewing with {reviewer.name}...")
+
+            review_result = reviewer.review_paper(paper_content)
+            reviews.append(review_result)
+
+            if review_result["success"] and review_result["score"] is not None:
+                total_score += review_result["score"]
+                successful_reviews += 1
+
+        avg_score = total_score / successful_reviews if successful_reviews > 0 else 0
+
+        if progress_callback:
+            progress_callback(1.0, "Review complete!")
+
+        return {
+            "reviews": reviews,
+            "average_score": avg_score,
+            "total_reviewers": len(self.reviewers),
+            "successful_reviews": successful_reviews
+        }

app.py

@@ -0,0 +1,306 @@
+"""Gradio app for AI-powered literature review system with Semantic Scholar integration."""
+
+import gradio as gr
+import os
+from typing import Optional, List, Dict
+from markitdown import MarkItDown
+from agents import MultiReviewerSystem
+import requests
+import time
+
+
+def extract_text_from_pdf(pdf_file) -> str:
+    """Extract text content from a PDF file using markitdown."""
+    try:
+        if pdf_file is None:
+            return ""
+
+        md = MarkItDown()
+        result = md.convert(pdf_file.name)
+        return result.text_content
+
+    except Exception as e:
+        return f"Error extracting text from PDF: {str(e)}"
+
+
+def search_semantic_scholar(query: str, limit: int = 5) -> List[Dict]:
+    """Search for related papers on Semantic Scholar."""
+    try:
+        url = "https://api.semanticscholar.org/graph/v1/paper/search"
+        params = {
+            "query": query,
+            "limit": limit,
+            "fields": "title,authors,year,abstract,citationCount,url,openAccessPdf"
+        }
+
+        response = requests.get(url, params=params)
+        response.raise_for_status()
+
+        data = response.json()
+        return data.get("data", [])
+
+    except Exception as e:
+        print(f"Error searching Semantic Scholar: {e}")
+        return []
+
+
+def format_semantic_scholar_results(papers: List[Dict]) -> str:
+    """Format Semantic Scholar results for display."""
+    if not papers:
+        return "No related papers found."
+
+    formatted = "## 📚 Related Papers from Semantic Scholar\n\n"
+
+    for i, paper in enumerate(papers, 1):
+        title = paper.get("title", "N/A")
+        authors = ", ".join([a.get("name", "") for a in paper.get("authors", [])])
+        year = paper.get("year", "N/A")
+        citations = paper.get("citationCount", 0)
+        abstract = paper.get("abstract", "No abstract available")
+        url = paper.get("url", "")
+        pdf_url = paper.get("openAccessPdf", {})
+
+        formatted += f"### {i}. {title}\n\n"
+        formatted += f"**Authors**: {authors}\n\n"
+        formatted += f"**Year**: {year} | **Citations**: {citations}\n\n"
+        formatted += f"**Abstract**: {abstract[:300]}{'...' if len(abstract) > 300 else ''}\n\n"
+
+        if url:
+            formatted += f"[View on Semantic Scholar]({url})"
+
+        if pdf_url and pdf_url.get("url"):
+            formatted += f" | [Download PDF]({pdf_url['url']})"
+
+        formatted += "\n\n---\n\n"
+
+    return formatted
+
+
+def extract_paper_title_from_text(text: str) -> str:
+    """Extract paper title from the beginning of the text."""
+    lines = text.split('\n')
+    for line in lines[:20]:  # Check first 20 lines
+        line = line.strip()
+        if len(line) > 20 and len(line) < 200:  # Reasonable title length
+            return line
+    return "Research Paper"
+
+
+def review_paper(
+    pdf_file,
+    api_key: str,
+    base_url: str,
+    model_name: str,
+    search_related: bool,
+    progress=gr.Progress()
+) -> tuple[str, str, str, str, str]:
+    """Main function to process PDF and generate reviews."""
+
+    if pdf_file is None:
+        return "Please upload a PDF file.", "", "", "", ""
+
+    # Get API credentials from environment or inputs
+    final_api_key = api_key if api_key else os.getenv("OPENAI_API_KEY", "")
+    final_base_url = base_url if base_url else os.getenv("OPENAI_BASE_URL", "https://api.openai.com/v1")
+    final_model = model_name if model_name else os.getenv("MODEL_NAME", "gpt-3.5-turbo")
+
+    if not final_api_key or final_api_key.strip() == "":
+        return "Please provide an API key or set OPENAI_API_KEY environment variable.", "", "", "", ""
+
+    # Extract text from PDF
+    progress(0.1, desc="Extracting text from PDF...")
+    paper_text = extract_text_from_pdf(pdf_file)
+
+    if paper_text.startswith("Error"):
+        return paper_text, "", "", "", ""
+
+    if len(paper_text.strip()) == 0:
+        return "Could not extract text from PDF. The file might be empty or image-based.", "", "", "", ""
+
+    # Search for related papers if requested
+    related_papers_md = ""
+    if search_related:
+        progress(0.2, desc="Searching for related papers...")
+        paper_title = extract_paper_title_from_text(paper_text)
+        related_papers = search_semantic_scholar(paper_title, limit=5)
+        related_papers_md = format_semantic_scholar_results(related_papers)
+        time.sleep(1)  # Rate limiting
+
+    # Initialize multi-reviewer system
+    progress(0.3, desc="Initializing reviewers...")
+
+    try:
+        reviewer_system = MultiReviewerSystem(
+            api_key=final_api_key,
+            base_url=final_base_url,
+            model=final_model
+        )
+
+        # Generate reviews
+        def progress_callback(value, desc):
+            progress(0.3 + (value * 0.7), desc=desc)
+
+        result = reviewer_system.review_paper_sequential(
+            paper_text,
+            progress_callback=progress_callback
+        )
+
+        # Format summary
+        summary = f"""
+## Review Summary
+
+**Average Score**: {result['average_score']:.2f}/10
+**Successful Reviews**: {result['successful_reviews']}/{result['total_reviewers']}
+
+---
+"""
+
+        # Extract individual reviews
+        review_1 = ""
+        review_2 = ""
+        review_3 = ""
+
+        for i, review_data in enumerate(result['reviews']):
+            score_text = f"{review_data['score']:.2f}/10" if review_data['score'] else 'N/A'
+            review_text = f"""
+### {review_data['reviewer']}
+
+**Score**: {score_text}
+
+{review_data['review']}
+
+---
+"""
+            if i == 0:
+                review_1 = review_text
+            elif i == 1:
+                review_2 = review_text
+            elif i == 2:
+                review_3 = review_text
+
+        return summary, review_1, review_2, review_3, related_papers_md
+
+    except Exception as e:
+        error_msg = f"Error during review process: {str(e)}"
+        return error_msg, "", "", "", related_papers_md
+
+
+# Create Gradio interface
+with gr.Blocks(title="AI Literature Review System", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 📚 AI-Powered Literature Review System
+
+    Upload a research paper (PDF) and get comprehensive reviews from multiple AI agents with different perspectives.
+
+    ## Features:
+    - **Multi-Agent Review**: Three specialized reviewers evaluate your paper sequentially
+    - **Comprehensive Analysis**: Originality, quality, clarity, significance, and more
+    - **Detailed Feedback**: Strengths, weaknesses, questions, and suggestions
+    - **Scoring System**: Based on top-tier conference standards (NeurIPS-style)
+    - **Semantic Scholar Integration**: Find related papers for comparison
+    """)
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### 📤 Upload & Configure")
+
+            with gr.Accordion("API Configuration", open=False):
+                api_key_input = gr.Textbox(
+                    label="API Key",
+                    type="password",
+                    placeholder="Leave empty to use OPENAI_API_KEY env var",
+                    info="Your OpenAI-compatible API key"
+                )
+
+                base_url_input = gr.Textbox(
+                    label="Base URL",
+                    placeholder="Leave empty to use OPENAI_BASE_URL env var or default",
+                    info="API base URL (e.g., https://api.openai.com/v1)"
+                )
+
+                model_input = gr.Textbox(
+                    label="Model Name",
+                    placeholder="Leave empty to use MODEL_NAME env var or default",
+                    info="Model identifier (e.g., gpt-4, gpt-3.5-turbo)"
+                )
+
+            pdf_input = gr.File(
+                label="Upload Research Paper (PDF)",
+                file_types=[".pdf"],
+                type="filepath"
+            )
+
+            search_related_checkbox = gr.Checkbox(
+                label="Search for related papers on Semantic Scholar",
+                value=True,
+                info="Find similar papers for comparison"
+            )
+
+            submit_btn = gr.Button("🔍 Review Paper", variant="primary", size="lg")
+
+            gr.Markdown("""
+            ### 👥 Reviewers (Sequential):
+            1. **Experimentalist**: Methodology and results
+            2. **Impactist**: Impact and significance
+            3. **Novelty Seeker**: Originality and innovation
+
+            ### 🔧 Setup:
+            Set environment variables in `.env`:
+            ```bash
+            OPENAI_API_KEY=your-key-here
+            OPENAI_BASE_URL=https://api.openai.com/v1
+            MODEL_NAME=gpt-4
+            ```
+            """)
+
+        with gr.Column(scale=2):
+            gr.Markdown("### 📊 Review Results")
+
+            summary_output = gr.Markdown(label="Summary")
+
+            with gr.Tabs():
+                with gr.Tab("Reviewer 1: Experimentalist"):
+                    review_1_output = gr.Markdown()
+
+                with gr.Tab("Reviewer 2: Impactist"):
+                    review_2_output = gr.Markdown()
+
+                with gr.Tab("Reviewer 3: Novelty Seeker"):
+                    review_3_output = gr.Markdown()
+
+                with gr.Tab("Related Papers"):
+                    related_papers_output = gr.Markdown()
+
+    # Connect the button to the review function
+    submit_btn.click(
+        fn=review_paper,
+        inputs=[pdf_input, api_key_input, base_url_input, model_input, search_related_checkbox],
+        outputs=[summary_output, review_1_output, review_2_output, review_3_output, related_papers_output]
+    )
+
+    gr.Markdown("""
+    ---
+    ### 📖 How to Use:
+    1. Configure your API settings (or use environment variables)
+    2. Upload your research paper in PDF format
+    3. Optionally enable Semantic Scholar search for related papers
+    4. Click "Review Paper" and wait for the sequential multi-agent analysis (2-5 minutes)
+    5. Review the detailed feedback from all three reviewers
+
+    ### 📊 Score Interpretation:
+    - **9-10**: Award Quality / Strong Accept
+    - **7-8**: Accept
+    - **5-6**: Borderline
+    - **3-4**: Borderline Reject
+    - **1-2**: Reject
+
+    ### ⚠️ Notes:
+    - Reviews are generated **sequentially** (one at a time) for better quality
+    - Processing time depends on paper length and API response time
+    - Ensure your PDF contains extractable text (not scanned images)
+    - Semantic Scholar API is rate-limited; use moderately
+    """)
+
+
+if __name__ == "__main__":
+    demo.launch(share=False)

requirements.txt

@@ -0,0 +1,5 @@
+gradio>=4.0.0
+markitdown>=0.0.1a2
+openai>=1.0.0
+requests>=2.31.0
+python-dotenv>=1.0.0