Upload 6 files

agents.py

@@ -0,0 +1,41 @@
+from crewai import Agent
+from langchain_google_genai import ChatGoogleGenerativeAI
+from tools import pmc_search, google_scholar_search, today_tool
+import os
+
+def get_gemini_llm():
+    return ChatGoogleGenerativeAI(
+        model="gemini-pro",
+        google_api_key=os.getenv('GEMINI_API_KEY'),
+        temperature=0.5,
+        convert_system_message_to_human=True,
+        top_p=0.8,
+        top_k=40,
+        max_output_tokens=2048
+    )
+
+def get_researcher_agent(verbose):
+    return Agent(
+        role="Medical Research Scientist",
+        goal="""Conduct thorough scientific literature review and synthesize findings into a comprehensive research summary.""",
+        backstory="""You are an expert medical research scientist with extensive experience in systematic reviews and meta-analyses. 
+                  You specialize in analyzing clinical studies, understanding research methodologies, and synthesizing evidence from multiple sources.
+                  Your expertise includes critical appraisal of medical literature, statistical analysis, and identification of key clinical findings.""",
+        llm=get_gemini_llm(),
+        tools=[pmc_search, google_scholar_search],
+        allow_delegation=False,
+        verbose=verbose
+    )
+
+def get_writer_agent(verbose):
+    return Agent(
+        role="Medical Writer",
+        goal="""Transform research findings into a well-structured, comprehensive scientific paper following academic standards.""",
+        backstory="""You are an experienced medical writer with expertise in creating high-quality scientific manuscripts.
+                  You excel at organizing complex medical information, maintaining scientific accuracy, and following academic writing standards.
+                  Your writing is clear, precise, and always supported by evidence from the literature.""",
+        llm=get_gemini_llm(),
+        tools=[today_tool],
+        allow_delegation=False,
+        verbose=verbose
+    )

app.py

@@ -0,0 +1,84 @@
+import gradio as gr
+import os
+from dotenv import load_dotenv
+from crew import get_crew
+import threading
+
+# Load environment variables
+load_dotenv()
+
+# Global lock for thread safety
+lock = threading.Lock()
+
+VERBOSE = False
+
+def invoke(topic):
+    """Generate scientific paper based on the topic"""
+    if not topic:
+        raise gr.Error("Topic is required.")
+    
+    with lock:
+        # Generate the paper
+        crew = get_crew(verbose=VERBOSE, topic=topic)
+        paper = str(crew.kickoff())
+        return paper
+
+# Create the Gradio interface
+css = """
+.gradio-container {
+    font-family: 'Arial', sans-serif;
+}
+.paper-output {
+    font-size: 16px;
+    line-height: 1.6;
+    padding: 20px;
+    background: #f9f9f9;
+    border-radius: 10px;
+    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+}
+"""
+
+demo = gr.Interface(
+    fn=invoke,
+    inputs=[
+        gr.Textbox(
+            label="Research Topic",
+            placeholder="Enter your research topic...",
+            lines=2
+        )
+    ],
+    outputs=[
+        gr.Markdown(
+            label="Generated Scientific Paper",
+            elem_classes="paper-output"
+        )
+    ],
+    title="AI Scientific Paper Generator",
+    description="""This application uses AI agents to generate comprehensive scientific papers. 
+                   The first agent researches your topic using PubMed Central and Google Scholar, 
+                   collecting at least 20 relevant articles. The second agent then synthesizes this 
+                   research into a well-structured scientific paper with proper citations.
+                   
+                   Created by Dr. Fernando Ly""",
+    article="""### How it works
+               1. Enter your research topic
+               2. The Research Agent will collect relevant scientific articles
+               3. The Writing Agent will generate a structured paper with:
+                  - Introduction
+                  - Materials and Methods
+                  - Results
+                  - Discussion
+                  - Conclusion
+                  - References (APA format)
+               
+               The paper will include proper citations and be based on real scientific literature.""",
+    css=css,
+    theme=gr.themes.Soft(
+        primary_hue="blue",
+        secondary_hue="gray"
+    )
+)
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch()

crew.py

@@ -0,0 +1,22 @@
+from crewai import Crew, Process
+from agents import get_researcher_agent, get_writer_agent
+from tasks import get_research_task, get_writing_task
+
+def get_crew(verbose=False, topic=None):
+    # Create Agents
+    researcher = get_researcher_agent(verbose)
+    writer = get_writer_agent(verbose)
+    
+    # Create Tasks
+    research_task = get_research_task(researcher, topic)
+    writing_task = get_writing_task(writer, topic)
+    
+    # Create Crew
+    crew = Crew(
+        agents=[researcher, writer],
+        tasks=[research_task, writing_task],
+        verbose=verbose,
+        process=Process.sequential
+    )
+    
+    return crew

requirements.txt

@@ -0,0 +1,8 @@
+crewai==0.11.0
+langchain-google-genai==0.0.6
+google-generativeai==0.3.2
+scholarly==1.7.11
+biopython==1.83
+beautifulsoup4==4.12.2
+python-dotenv==1.0.0
+gradio==4.8.0

tasks.py

@@ -0,0 +1,92 @@
+from crewai import Task
+
+def get_research_task(agent, topic):
+    return Task(
+        description=f"""Research the topic "{topic}" extensively using PMC and Google Scholar.
+                      
+                      Follow these steps:
+                      1. First search PMC using the pmc_search tool
+                      2. Then search Google Scholar using the google_scholar_search tool
+                      3. For each source, carefully extract and analyze:
+                         - Title
+                         - Authors
+                         - Publication year
+                         - Key findings from abstract
+                         - Methodology used
+                         - Outcomes reported
+                      4. Combine and synthesize the information:
+                         - Identify common themes
+                         - Note conflicting findings
+                         - Highlight strongest evidence
+                      5. Organize findings by:
+                         - Study type (RCT, cohort, etc.)
+                         - Sample size
+                         - Follow-up duration
+                         - Outcome measures
+                      
+                      If search results are limited:
+                      1. Try alternative search terms
+                      2. Broaden the search scope
+                      3. Include related conditions/treatments
+                      
+                      Output Format:
+                      1. Summary of search strategy
+                      2. Overview of findings
+                      3. Detailed analysis of key studies
+                      4. Evidence synthesis
+                      5. Knowledge gaps identified""",
+        agent=agent,
+        expected_output="A comprehensive research summary with detailed analysis of findings from both PMC and Google Scholar."
+    )
+
+def get_writing_task(agent, topic):
+    return Task(
+        description=f"""Write a comprehensive scientific paper about "{topic}" based on the research provided.
+                      
+                      Paper Structure:
+                      1. Introduction:
+                         - Current state of knowledge
+                         - Clinical significance
+                         - Research gaps
+                         - Clear objectives
+                      
+                      2. Materials and Methods:
+                         - Search strategy
+                         - Inclusion criteria
+                         - Data extraction process
+                         - Quality assessment
+                      
+                      3. Results (minimum one page):
+                         - Study characteristics
+                         - Patient demographics
+                         - Primary outcomes
+                         - Secondary outcomes
+                         - Safety data
+                         - Meta-analysis if applicable
+                      
+                      4. Discussion (minimum one page):
+                         - Summary of main findings
+                         - Comparison with existing literature
+                         - Clinical implications
+                         - Strengths and limitations
+                         - Future research directions
+                      
+                      5. Conclusion:
+                         - Key takeaways
+                         - Clinical recommendations
+                         - Research priorities
+                      
+                      6. References:
+                         - APA format
+                         - All cited studies included
+                      
+                      Writing Guidelines:
+                      - Use clear, scientific language
+                      - Support all claims with evidence
+                      - Include relevant statistics
+                      - Maintain objectivity
+                      - Address conflicting findings
+                      - Consider clinical relevance""",
+        agent=agent,
+        expected_output="A well-structured scientific paper with comprehensive analysis and proper citations."
+    )

tools.py

@@ -0,0 +1,158 @@
+from langchain.tools import tool
+from scholarly import scholarly, ProxyGenerator
+from bs4 import BeautifulSoup
+import requests
+import datetime
+import json
+import time
+
+# Configure scholarly with proxy to avoid blocking
+pg = ProxyGenerator()
+pg.FreeProxies()
+scholarly.use_proxy(pg)
+
+@tool
+def pmc_search(query: str) -> str:
+    """Search PubMed Central (PMC) for articles"""
+    try:
+        # Base URLs for PubMed APIs
+        search_url = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi"
+        fetch_url = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi"
+        
+        # Search parameters
+        search_params = {
+            "db": "pmc",
+            "term": query,
+            "retmax": 20,
+            "retmode": "json",
+            "sort": "relevance"
+        }
+        
+        # Get article IDs
+        response = requests.get(search_url, params=search_params)
+        if not response.ok:
+            return json.dumps([{"error": "PubMed search failed"}])
+            
+        try:
+            search_data = response.json()
+            article_ids = search_data.get("esearchresult", {}).get("idlist", [])
+        except:
+            # Fallback to XML parsing if JSON fails
+            soup = BeautifulSoup(response.text, 'xml')
+            article_ids = [id.text for id in soup.find_all('Id')]
+        
+        articles = []
+        for pmid in article_ids:
+            try:
+                # Fetch article details
+                fetch_params = {
+                    "db": "pmc",
+                    "id": pmid,
+                    "retmode": "xml"
+                }
+                article_response = requests.get(fetch_url, params=fetch_params)
+                if not article_response.ok:
+                    continue
+                    
+                article_soup = BeautifulSoup(article_response.text, 'xml')
+                
+                # Extract article data
+                title_elem = article_soup.find("article-title")
+                title = title_elem.text if title_elem else "No title"
+                
+                abstract_elem = article_soup.find("abstract")
+                abstract = abstract_elem.text if abstract_elem else "No abstract"
+                
+                authors = []
+                for author in article_soup.find_all(["author", "contrib"]):
+                    surname = author.find(["surname", "last-name"])
+                    given_name = author.find(["given-names", "first-name"])
+                    if surname:
+                        author_name = surname.text
+                        if given_name:
+                            author_name = f"{given_name.text} {author_name}"
+                        authors.append(author_name)
+                
+                year_elem = article_soup.find(["pub-date", "year"])
+                year = year_elem.find("year").text if year_elem and year_elem.find("year") else "Unknown"
+                
+                journal_elem = article_soup.find(["journal-title", "source"])
+                journal = journal_elem.text if journal_elem else "Unknown Journal"
+                
+                articles.append({
+                    "id": pmid,
+                    "title": title,
+                    "authors": authors,
+                    "year": year,
+                    "journal": journal,
+                    "abstract": abstract
+                })
+                
+                # Add delay to avoid rate limiting
+                time.sleep(0.5)
+                
+            except Exception as e:
+                continue
+        
+        return json.dumps(articles, indent=2)
+        
+    except Exception as e:
+        return json.dumps([{"error": f"PMC search failed: {str(e)}"}])
+
+@tool
+def google_scholar_search(query: str) -> str:
+    """Search Google Scholar for articles"""
+    try:
+        # Configure proxy and retry mechanism
+        if not scholarly.use_proxy(pg):
+            pg.FreeProxies()
+            scholarly.use_proxy(pg)
+        
+        search_query = scholarly.search_pubs(query)
+        results = []
+        count = 0
+        max_retries = 3
+        
+        while count < 20:
+            try:
+                result = next(search_query)
+                
+                # Extract publication data
+                pub = {
+                    "title": result.bib.get('title', 'No title'),
+                    "authors": result.bib.get('author', 'No author').split(" and "),
+                    "year": result.bib.get('year', 'No year'),
+                    "abstract": result.bib.get('abstract', 'No abstract'),
+                    "journal": result.bib.get('journal', result.bib.get('venue', 'No venue')),
+                    "citations": result.citedby if hasattr(result, 'citedby') else 0
+                }
+                
+                # Skip if no title or abstract
+                if pub["title"] == 'No title' or pub["abstract"] == 'No abstract':
+                    continue
+                    
+                results.append(pub)
+                count += 1
+                
+                # Add delay to avoid rate limiting
+                time.sleep(0.5)
+                
+            except StopIteration:
+                break
+            except Exception as e:
+                if max_retries > 0:
+                    max_retries -= 1
+                    time.sleep(1)
+                    continue
+                else:
+                    break
+        
+        return json.dumps(results, indent=2)
+        
+    except Exception as e:
+        return json.dumps([{"error": f"Google Scholar search failed: {str(e)}"}])
+
+@tool
+def today_tool() -> str:
+    """Get today's date"""
+    return str(datetime.date.today())