python -m venv venv
source venv/bin/activate
pip install biopython requests openai pydantic

# pubmed/client.py
from Bio import Entrez
from typing import List, Dict, Optional
import time
import logging

logger = logging.getLogger(__name__)
Entrez.email = "research-agent@example.com"

class PubMedClient:
    def __init__(self, api_key: Optional[str] = None):
        if api_key:
            Entrez.api_key = api_key

    def search(self, query: str, max_results: int = 20) -> List[str]:
        handle = Entrez.esearch(db="pubmed", term=query, retmax=max_results, sort="relevance", usehistory="y")
        results = Entrez.read(handle)
        handle.close()
        return results.get("IdList", [])

    def fetch_papers(self, pmids: List[str]) -> List[Dict]:
        if not pmids:
            return []
        handle = Entrez.efetch(db="pubmed", id=",".join(pmids), rettype="xml", retmode="xml")
        records = Entrez.read(handle)
        handle.close()
        return [self._parse_article(a) for a in records.get("PubmedArticle", [])]

    def _parse_article(self, article: dict) -> Dict:
        medline = article.get("MedlineCitation", {})
        article_data = medline.get("Article", {})
        abstract_parts = article_data.get("Abstract", {}).get("AbstractText", [])
        abstract = " ".join(str(p) for p in abstract_parts)
        authors = []
        for author in article_data.get("AuthorList", []):
            last, first = author.get("LastName", ""), author.get("ForeName", "")
            if last:
                authors.append(f"{last}, {first}")
        return {
            "pmid": str(medline.get("PMID", "")),
            "title": article_data.get("ArticleTitle", "No title"),
            "abstract": abstract,
            "authors": authors,
            "journal": article_data.get("Journal", {}).get("Title", ""),
            "year": article_data.get("Journal", {}).get("JournalIssue", {}).get("PubDate", {}).get("Year", ""),
            "keywords": [kw.strip() for kw in medline.get("KeywordList", [[]])[0]] if medline.get("KeywordList") else [],
        }

    def search_and_fetch(self, query: str, max_results: int = 10) -> List[Dict]:
        pmids = self.search(query, max_results)
        time.sleep(0.5)
        return self.fetch_papers(pmids)

# processing/paper_parser.py
import json
from typing import Dict
from openai import OpenAI

class PaperParser:
    def __init__(self, model: str = "gpt-4o"):
        self.client = OpenAI()
        self.model = model

    def extract_structure(self, paper: Dict) -> Dict:
        response = self.client.chat.completions.create(
            model=self.model,
            messages=[
                {"role": "system", "content": """Extract structured info from this medical paper. Return JSON:
                {"study_design": "RCT|cohort|case-control|cross-sectional|case-report|review|meta-analysis",
                 "sample_size": number or null, "population": "description",
                 "key_findings": ["list"], "limitations": ["list"],
                 "evidence_level": "1a|1b|2a|2b|3|4|5"}"""},
                {"role": "user", "content": f"Title: {paper['title']}\nAbstract: {paper['abstract']}"},
            ],
            temperature=0.0,
        )
        try:
            return json.loads(response.choices[0].message.content)
        except (json.JSONDecodeError, IndexError):
            return {"study_design": "unknown", "evidence_level": "5"}

# processing/summarizer.py
from typing import Dict, List
from openai import OpenAI

class PaperSummarizer:
    def __init__(self, model: str = "gpt-4o"):
        self.client = OpenAI()
        self.model = model

    def summarize_paper(self, paper: Dict) -> str:
        response = self.client.chat.completions.create(
            model=self.model,
            messages=[
                {"role": "system", "content": "Summarize for a clinician. Include: objective, methods, key findings, implications. 150-200 words."},
                {"role": "user", "content": f"Title: {paper['title']}\nAuthors: {', '.join(paper['authors'][:3])}\n{paper['abstract']}"},
            ],
            temperature=0.2,
        )
        return response.choices[0].message.content

    def synthesize_evidence(self, papers: List[Dict], question: str) -> str:
        summaries = [f"- {p['title']} ({p['year']})\n  {p.get('abstract', '')[:300]}" for p in papers[:10]]
        response = self.client.chat.completions.create(
            model=self.model,
            messages=[
                {"role": "system", "content": "Synthesize evidence. Provide: conclusion, consistency, gaps. Use GRADE-like language."},
                {"role": "user", "content": f"Question: {question}\n\nStudies:\n" + "\n\n".join(summaries)},
            ],
            temperature=0.3,
        )
        return response.choices[0].message.content

    def format_citation(self, paper: Dict, style: str = "AMA") -> str:
        authors = paper["authors"]
        author_str = f"{authors[0]}, et al." if len(authors) > 3 else ", ".join(authors)
        if style == "AMA":
            return f"{author_str}. {paper['title']}. {paper['journal']}. {paper['year']}"
        elif style == "APA":
            return f"{author_str} ({paper['year']}). {paper['title']}. {paper['journal']}"
        return f"{author_str}. {paper['title']}. {paper['journal']}. {paper['year']}"

# agent.py
from pubmed.client import PubMedClient
from processing.paper_parser import PaperParser
from processing.summarizer import PaperSummarizer
from typing import Dict

class MedicalResearchAgent:
    def __init__(self, model: str = "gpt-4o", api_key: str = None):
        self.pubmed = PubMedClient(api_key=api_key)
        self.parser = PaperParser(model)
        self.summarizer = PaperSummarizer(model)

    def research(self, question: str, max_papers: int = 15) -> Dict:
        papers = self.pubmed.search_and_fetch(question, max_papers)
        analyzed = []
        for paper in papers:
            structure = self.parser.extract_structure(paper)
            summary = self.summarizer.summarize_paper(paper)
            analyzed.append({
                **paper,
                "structure": structure,
                "summary": summary,
                "citation_ama": self.summarizer.format_citation(paper, "AMA"),
                "citation_apa": self.summarizer.format_citation(paper, "APA"),
            })
        synthesis = self.summarizer.synthesize_evidence(analyzed, question)
        return {
            "question": question,
            "total_papers": len(analyzed),
            "papers": analyzed,
            "synthesis": synthesis,
            "evidence_levels": [p["structure"].get("evidence_level", "5") for p in analyzed],
        }

    def get_paper_details(self, pmid: str) -> Dict:
        papers = self.pubmed.fetch_papers([pmid])
        if not papers:
            return {"error": "Paper not found"}
        paper = papers[0]
        return {
            **paper,
            "structure": self.parser.extract_structure(paper),
            "summary": self.summarizer.summarize_paper(paper),
        }