Update app.py

app.py

@@ -12,7 +12,7 @@ import plotly.graph_objects as go
 from transformers import pipeline
 import numpy as np
 
-class CancerResearchLiteratureMiner:
+class VeterinaryLiteratureMiner:
     def __init__(self):
         # Initialize NLP pipelines
         try:
@@ -23,24 +23,54 @@ class CancerResearchLiteratureMiner:
             self.summarizer = None
             self.classifier = None
         
-        # Research categories for classification
-        self.research_categories = [
-            "drug discovery", "immunotherapy", "chemotherapy", "radiation therapy",
-            "biomarkers", "diagnostics", "metastasis", "tumor microenvironment",
-            "animal models", "preclinical studies", "toxicity", "pharmacokinetics"
+        # Veterinary research categories for classification
+        self.veterinary_categories = [
+            "oncology", "cardiology", "dermatology", "neurology", "orthopedics",
+            "infectious diseases", "parasitology", "pharmacology", "toxicology",
+            "surgery", "anesthesia", "emergency medicine", "internal medicine",
+            "pathology", "radiology", "nutrition", "behavior", "reproduction",
+            "public health", "zoonoses", "immunology", "genetics", "epidemiology"
         ]
         
-        # Animal model keywords
-        self.animal_keywords = [
-            "mouse", "mice", "rat", "rats", "xenograft", "orthotopic", "transgenic",
-            "knockout", "immunodeficient", "nude mice", "SCID", "NOD", "PDX",
-            "patient-derived xenograft", "syngeneic", "canine", "dog", "feline", "cat"
+        # Animal species categories
+        self.animal_species = [
+            "canine", "dog", "dogs", "feline", "cat", "cats", "equine", "horse", "horses",
+            "bovine", "cattle", "cow", "cows", "porcine", "pig", "pigs", "swine",
+            "ovine", "sheep", "caprine", "goat", "goats", "avian", "bird", "birds",
+            "poultry", "chicken", "chickens", "rabbit", "rabbits", "ferret", "ferrets",
+            "reptile", "reptiles", "fish", "aquatic", "wildlife", "zoo", "exotic",
+            "laboratory animals", "mouse", "mice", "rat", "rats"
         ]
+        
+        # Veterinary specialties and procedures
+        self.vet_procedures = [
+            "vaccination", "spay", "neuter", "castration", "ovariohysterectomy",
+            "amputation", "biopsy", "endoscopy", "laparoscopy", "arthroscopy",
+            "radiography", "ultrasound", "CT", "MRI", "chemotherapy", "radiation",
+            "physical therapy", "rehabilitation", "dental", "ophthalmology"
+        ]
+        
+        # Common veterinary conditions
+        self.vet_conditions = [
+            "diabetes", "epilepsy", "heart disease", "kidney disease", "liver disease",
+            "arthritis", "hip dysplasia", "allergies", "skin disease", "cancer",
+            "tumor", "infection", "parasite", "heartworm", "flea", "tick",
+            "obesity", "dental disease", "cataracts", "glaucoma", "IBD"
+        ]
+
+    def search_veterinary_literature(self, query: str, max_results: int = 50, database: str = "pubmed") -> List[Dict]:
+        """Search veterinary literature across multiple databases"""
+        
+        if database == "pubmed":
+            return self._search_pubmed(query, max_results)
+        else:
+            # Future: Could add other veterinary databases here
+            return self._search_pubmed(query, max_results)
 
-    def search_pubmed(self, query: str, max_results: int = 50) -> List[Dict]:
-        """Search PubMed for cancer research papers"""
-        # Enhance query with animal model terms
-        enhanced_query = f"({query}) AND (animal model OR mouse OR mice OR rat OR xenograft OR preclinical)"
+    def _search_pubmed(self, query: str, max_results: int) -> List[Dict]:
+        """Search PubMed for veterinary papers"""
+        # Enhance query with veterinary terms
+        enhanced_query = f"({query}) AND (veterinary OR animal OR pet OR livestock OR zoo OR wildlife)"
         
         # Search PubMed
         search_url = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi"
@@ -123,19 +153,33 @@ class CancerResearchLiteratureMiner:
         
         return papers
 
-    def analyze_papers(self, papers: List[Dict]) -> Dict:
-        """Analyze the retrieved papers for insights"""
+    def analyze_veterinary_papers(self, papers: List[Dict]) -> Dict:
+        """Analyze the retrieved veterinary papers for insights"""
         if not papers or papers[0].get("error"):
             return {"error": "No papers to analyze"}
         
         analysis = {
             "total_papers": len(papers),
             "year_distribution": {},
-            "animal_models": {},
-            "research_categories": {},
-            "key_findings": [],
+            "animal_species": {},
+            "veterinary_specialties": {},
+            "common_conditions": {},
+            "procedures_mentioned": {},
             "drug_mentions": [],
-            "methodology_trends": {}
+            "journal_distribution": {},
+            "research_trends": {}
+        }
+        
+        # Keywords for different categories
+        specialty_keywords = {
+            "oncology": ["cancer", "tumor", "oncology", "chemotherapy", "radiation"],
+            "cardiology": ["heart", "cardiac", "cardiology", "arrhythmia", "murmur"],
+            "dermatology": ["skin", "dermatology", "allergy", "dermatitis", "eczema"],
+            "neurology": ["brain", "neurological", "seizure", "epilepsy", "paralysis"],
+            "orthopedics": ["bone", "joint", "fracture", "orthopedic", "lameness"],
+            "infectious_diseases": ["infection", "bacteria", "virus", "antibiotic", "pathogen"],
+            "surgery": ["surgical", "surgery", "operative", "laparoscopy", "endoscopy"],
+            "internal_medicine": ["diabetes", "kidney", "liver", "endocrine", "metabolic"]
         }
         
         # Analyze each paper
@@ -144,42 +188,71 @@ class CancerResearchLiteratureMiner:
             year = paper.get("year", "Unknown")
             analysis["year_distribution"][year] = analysis["year_distribution"].get(year, 0) + 1
             
-            # Analyze abstract for animal models and categories
+            # Journal distribution
+            journal = paper.get("journal", "Unknown")
+            analysis["journal_distribution"][journal] = analysis["journal_distribution"].get(journal, 0) + 1
+            
+            # Analyze abstract and title
             abstract = paper.get("abstract", "").lower()
             title = paper.get("title", "").lower()
             full_text = f"{title} {abstract}"
             
-            # Animal model detection
-            for animal in self.animal_keywords:
-                if animal in full_text:
-                    analysis["animal_models"][animal] = analysis["animal_models"].get(animal, 0) + 1
+            # Animal species detection
+            for species in self.animal_species:
+                if species in full_text:
+                    species_key = species.replace(" ", "_")
+                    analysis["animal_species"][species_key] = analysis["animal_species"].get(species_key, 0) + 1
+            
+            # Veterinary specialty detection
+            for specialty, keywords in specialty_keywords.items():
+                for keyword in keywords:
+                    if keyword in full_text:
+                        analysis["veterinary_specialties"][specialty] = analysis["veterinary_specialties"].get(specialty, 0) + 1
+                        break
+            
+            # Common conditions detection
+            for condition in self.vet_conditions:
+                if condition in full_text:
+                    analysis["common_conditions"][condition] = analysis["common_conditions"].get(condition, 0) + 1
+            
+            # Procedures detection
+            for procedure in self.vet_procedures:
+                if procedure in full_text:
+                    analysis["procedures_mentioned"][procedure] = analysis["procedures_mentioned"].get(procedure, 0) + 1
+            
+            # Extract drug mentions (veterinary drugs and general pharmaceuticals)
+            drugs = re.findall(r'\b[A-Z][a-z]*(?:mab|nib|ine|ole|cin|tin|zole|pril|sartan)\b', paper.get("abstract", ""))
+            # Add common veterinary drugs
+            vet_drugs = ["prednisolone", "dexamethasone", "amoxicillin", "cephalexin", "enrofloxacin", 
+                        "tramadol", "gabapentin", "furosemide", "enalapril", "pimobendan"]
+            for drug in vet_drugs:
+                if drug in full_text:
+                    drugs.append(drug.title())
             
-            # Extract drug mentions (simple regex for common drug patterns)
-            drugs = re.findall(r'\b[A-Z][a-z]*(?:mab|nib|ine|ole|cin|tin)\b', paper.get("abstract", ""))
             analysis["drug_mentions"].extend(drugs)
             
             # Classify research category if classifier is available
             if self.classifier and abstract != "n/a":
                 try:
-                    result = self.classifier(abstract[:512], self.research_categories)
+                    result = self.classifier(abstract[:512], self.veterinary_categories)
                     top_category = result["labels"][0]
-                    analysis["research_categories"][top_category] = analysis["research_categories"].get(top_category, 0) + 1
+                    analysis["research_trends"][top_category] = analysis["research_trends"].get(top_category, 0) + 1
                 except Exception:
                     pass
         
         # Process drug mentions
         drug_counter = Counter(analysis["drug_mentions"])
-        analysis["drug_mentions"] = dict(drug_counter.most_common(10))
+        analysis["drug_mentions"] = dict(drug_counter.most_common(15))
         
         return analysis
 
-    def generate_summary(self, papers: List[Dict], analysis: Dict) -> str:
-        """Generate a comprehensive summary of findings"""
+    def generate_veterinary_summary(self, papers: List[Dict], analysis: Dict) -> str:
+        """Generate a comprehensive summary of veterinary literature findings"""
         if not papers or papers[0].get("error"):
             return "No papers found or error in retrieval."
         
         summary = f"""
-# Literature Mining Summary
+# Veterinary Literature Mining Summary
 
 ## Overview
 - **Total Papers Found**: {analysis['total_papers']}
@@ -187,108 +260,143 @@ class CancerResearchLiteratureMiner:
 
 ## Key Insights
 
-### Animal Models Used
+### Most Studied Animal Species
 """
         
-        # Top animal models
-        if analysis["animal_models"]:
-            top_models = sorted(analysis["animal_models"].items(), key=lambda x: x[1], reverse=True)[:5]
-            for model, count in top_models:
-                summary += f"- **{model.title()}**: {count} papers\n"
+        # Top animal species
+        if analysis["animal_species"]:
+            top_species = sorted(analysis["animal_species"].items(), key=lambda x: x[1], reverse=True)[:8]
+            for species, count in top_species:
+                formatted_species = species.replace("_", " ").title()
+                summary += f"- **{formatted_species}**: {count} papers\n"
         
-        summary += "\n### Research Focus Areas\n"
+        summary += "\n### Veterinary Specialties Focus\n"
         
-        # Research categories
-        if analysis["research_categories"]:
-            top_categories = sorted(analysis["research_categories"].items(), key=lambda x: x[1], reverse=True)[:5]
-            for category, count in top_categories:
-                summary += f"- **{category.title()}**: {count} papers\n"
+        # Veterinary specialties
+        if analysis["veterinary_specialties"]:
+            top_specialties = sorted(analysis["veterinary_specialties"].items(), key=lambda x: x[1], reverse=True)[:6]
+            for specialty, count in top_specialties:
+                formatted_specialty = specialty.replace("_", " ").title()
+                summary += f"- **{formatted_specialty}**: {count} papers\n"
         
-        summary += "\n### Frequently Mentioned Drugs\n"
+        summary += "\n### Common Conditions Studied\n"
+        
+        # Common conditions
+        if analysis["common_conditions"]:
+            top_conditions = sorted(analysis["common_conditions"].items(), key=lambda x: x[1], reverse=True)[:8]
+            for condition, count in top_conditions:
+                summary += f"- **{condition.title()}**: {count} papers\n"
+        
+        summary += "\n### Frequently Mentioned Treatments/Drugs\n"
         
         # Drug mentions
         if analysis["drug_mentions"]:
-            for drug, count in list(analysis["drug_mentions"].items())[:5]:
+            for drug, count in list(analysis["drug_mentions"].items())[:8]:
                 summary += f"- **{drug}**: {count} mentions\n"
         
-        summary += "\n### Recent Highlights\n"
+        summary += "\n### Top Veterinary Journals\n"
+        
+        # Journal distribution
+        if analysis["journal_distribution"]:
+            top_journals = sorted(analysis["journal_distribution"].items(), key=lambda x: x[1], reverse=True)[:5]
+            for journal, count in top_journals:
+                summary += f"- **{journal}**: {count} papers\n"
         
-        # Recent papers (last 2 years)
+        summary += "\n### Recent Research Highlights\n"
+        
+        # Recent papers (last 3 years)
         current_year = datetime.now().year
-        recent_papers = [p for p in papers if p.get("year", "").isdigit() and int(p["year"]) >= current_year - 2]
+        recent_papers = [p for p in papers if p.get("year", "").isdigit() and int(p["year"]) >= current_year - 3]
         
-        for paper in recent_papers[:3]:
+        for paper in recent_papers[:4]:
             summary += f"- **{paper.get('title', 'N/A')}** ({paper.get('year', 'N/A')})\n"
             summary += f"  *{paper.get('journal', 'N/A')}*\n\n"
         
         return summary
 
-    def create_visualizations(self, analysis: Dict):
-        """Create visualization plots"""
+    def create_veterinary_visualizations(self, analysis: Dict):
+        """Create visualization plots for veterinary data"""
         plots = {}
         
         # Year distribution
         if analysis["year_distribution"]:
-            years = list(analysis["year_distribution"].keys())
-            counts = list(analysis["year_distribution"].values())
+            years = [y for y in analysis["year_distribution"].keys() if y.isdigit()]
+            counts = [analysis["year_distribution"][y] for y in years]
             
-            fig_year = px.bar(
+            fig_year = px.line(
                 x=years, y=counts,
-                title="Publication Year Distribution",
-                labels={"x": "Year", "y": "Number of Papers"}
+                title="Veterinary Research Publications Over Time",
+                labels={"x": "Year", "y": "Number of Papers"},
+                markers=True
             )
+            fig_year.update_layout(showlegend=False)
             plots["year_dist"] = fig_year
         
-        # Animal models
-        if analysis["animal_models"]:
-            models = list(analysis["animal_models"].keys())[:10]
-            model_counts = [analysis["animal_models"][m] for m in models]
+        # Animal species
+        if analysis["animal_species"]:
+            species = list(analysis["animal_species"].keys())[:12]
+            species_counts = [analysis["animal_species"][s] for s in species]
+            formatted_species = [s.replace("_", " ").title() for s in species]
             
-            fig_models = px.bar(
-                x=model_counts, y=models,
+            fig_species = px.bar(
+                x=species_counts, y=formatted_species,
                 orientation='h',
-                title="Most Common Animal Models",
-                labels={"x": "Number of Papers", "y": "Animal Model"}
+                title="Most Studied Animal Species",
+                labels={"x": "Number of Papers", "y": "Species"}
             )
-            plots["animal_models"] = fig_models
+            plots["animal_species"] = fig_species
         
-        # Research categories
-        if analysis["research_categories"]:
-            categories = list(analysis["research_categories"].keys())
-            cat_counts = list(analysis["research_categories"].values())
+        # Veterinary specialties
+        if analysis["veterinary_specialties"]:
+            specialties = list(analysis["veterinary_specialties"].keys())
+            spec_counts = list(analysis["veterinary_specialties"].values())
+            formatted_specialties = [s.replace("_", " ").title() for s in specialties]
             
-            fig_categories = px.pie(
-                values=cat_counts, names=categories,
-                title="Research Focus Distribution"
+            fig_specialties = px.pie(
+                values=spec_counts, names=formatted_specialties,
+                title="Veterinary Specialty Distribution"
             )
-            plots["categories"] = fig_categories
+            plots["specialties"] = fig_specialties
+        
+        # Common conditions
+        if analysis["common_conditions"]:
+            conditions = list(analysis["common_conditions"].keys())[:10]
+            condition_counts = [analysis["common_conditions"][c] for c in conditions]
+            
+            fig_conditions = px.bar(
+                x=[c.title() for c in conditions], y=condition_counts,
+                title="Most Commonly Studied Conditions",
+                labels={"x": "Condition", "y": "Number of Papers"}
+            )
+            fig_conditions.update_xaxes(tickangle=45)
+            plots["conditions"] = fig_conditions
         
         return plots
 
-def create_gradio_interface():
-    """Create the Gradio interface"""
-    miner = CancerResearchLiteratureMiner()
+def create_veterinary_gradio_interface():
+    """Create the Gradio interface for veterinary literature mining"""
+    miner = VeterinaryLiteratureMiner()
     
-    def search_and_analyze(query, max_results):
-        """Main function to search and analyze literature"""
+    def search_and_analyze_vet(query, max_results, database):
+        """Main function to search and analyze veterinary literature"""
         if not query.strip():
-            return "Please enter a search query.", None, None, None, None
+            return "Please enter a search query.", None, None, None, None, None
         
         # Search papers
-        papers = miner.search_pubmed(query, max_results)
+        papers = miner.search_veterinary_literature(query, max_results, database)
         
         if not papers or papers[0].get("error"):
             error_msg = papers[0].get("error", "No papers found") if papers else "No papers found"
-            return f"Error: {error_msg}", None, None, None, None
+            return f"Error: {error_msg}", None, None, None, None, None
         
         # Analyze papers
-        analysis = miner.analyze_papers(papers)
+        analysis = miner.analyze_veterinary_papers(papers)
         
         # Generate summary
-        summary = miner.generate_summary(papers, analysis)
+        summary = miner.generate_veterinary_summary(papers, analysis)
         
         # Create visualizations
-        plots = miner.create_visualizations(analysis)
+        plots = miner.create_veterinary_visualizations(analysis)
         
         # Create papers dataframe
         papers_df = pd.DataFrame([
@@ -306,98 +414,120 @@ def create_gradio_interface():
             summary,
             papers_df,
             plots.get("year_dist"),
-            plots.get("animal_models"),
-            plots.get("categories")
+            plots.get("animal_species"),
+            plots.get("specialties"),
+            plots.get("conditions")
         )
     
     # Create interface
-    with gr.Blocks(title="Veterinary Oncology Assistant", theme=gr.themes.Soft()) as interface:
+    with gr.Blocks(title="Veterinary Literature Mining Agent", theme=gr.themes.Soft()) as interface:
         gr.Markdown("""
-        # Veterinary Oncology Assistant
+        # 🐾 Veterinary Literature Mining Agent
         
-        This AI agent searches and analyzes scientific literature related to cancer research in animal models.
-        It automatically extracts insights about animal models used, research focus areas, and emerging trends.
+        This AI agent searches and analyzes veterinary and animal health literature across all specialties.
+        It automatically extracts insights about animal species, veterinary specialties, common conditions, and treatment trends.
         
         **Features:**
-        - PubMed literature search with animal model focus
-        - Automatic categorization of research areas
-        - Drug mention extraction
-        - Publication trend analysis
+        - Comprehensive veterinary literature search
+        - Multi-species analysis (companion animals, livestock, wildlife, exotics)
+        - Veterinary specialty categorization
+        - Treatment and drug trend analysis
         - Interactive visualizations
+        - Journal and publication pattern analysis
         """)
         
         with gr.Row():
             with gr.Column(scale=2):
                 query_input = gr.Textbox(
                     label="Research Query",
-                    placeholder="e.g., 'breast cancer immunotherapy', 'lung cancer biomarkers', 'pancreatic cancer treatment'",
+                    placeholder="e.g., 'canine diabetes management', 'equine lameness diagnosis', 'feline kidney disease', 'wildlife conservation medicine'",
                     lines=2
                 )
-                max_results = gr.Slider(
-                    minimum=10, maximum=100, value=50, step=10,
-                    label="Maximum Results"
-                )
-                search_btn = gr.Button("🔍 Search & Analyze Literature", variant="primary")
+                with gr.Row():
+                    max_results = gr.Slider(
+                        minimum=10, maximum=100, value=50, step=10,
+                        label="Maximum Results"
+                    )
+                    database_choice = gr.Dropdown(
+                        choices=["pubmed"],
+                        value="pubmed",
+                        label="Database"
+                    )
+                search_btn = gr.Button("🔍 Search Veterinary Literature", variant="primary")
             
             with gr.Column(scale=1):
                 gr.Markdown("""
-                ### Tips for Better Results:
-                - Use specific cancer types (e.g., "breast cancer", "melanoma")
-                - Include treatment modalities (e.g., "immunotherapy", "chemotherapy")
-                - Add animal model terms (e.g., "mouse model", "xenograft")
+                ### Search Tips:
+                - **Species**: dog, cat, horse, cattle, pig, bird, fish, reptile, wildlife
+                - **Specialties**: cardiology, oncology, surgery, dermatology, neurology
+                - **Conditions**: diabetes, arthritis, cancer, infection, allergies
+                - **Procedures**: vaccination, surgery, imaging, therapy
+                - **Combine terms**: "feline diabetes insulin therapy"
                 """)
         
         with gr.Tabs():
-            with gr.TabItem("Summary & Insights"):
-                summary_output = gr.Markdown(label="Analysis Summary")
+            with gr.TabItem("📊 Analysis Summary"):
+                summary_output = gr.Markdown(label="Veterinary Literature Analysis")
             
-            with gr.TabItem("Papers Found"):
+            with gr.TabItem("📋 Research Papers"):
                 papers_output = gr.Dataframe(
                     headers=["PMID", "Title", "Authors", "Journal", "Year"],
-                    label="Retrieved Papers"
+                    label="Retrieved Veterinary Papers"
                 )
             
-            with gr.TabItem("Visualizations"):
+            with gr.TabItem("📈 Research Trends"):
                 with gr.Row():
                     year_plot = gr.Plot(label="Publication Timeline")
-                    models_plot = gr.Plot(label="Animal Models")
+                    species_plot = gr.Plot(label="Animal Species")
                 with gr.Row():
-                    categories_plot = gr.Plot(label="Research Categories")
+                    specialties_plot = gr.Plot(label="Veterinary Specialties")
+                    conditions_plot = gr.Plot(label="Common Conditions")
         
         # Connect the search function
         search_btn.click(
-            search_and_analyze,
-            inputs=[query_input, max_results],
-            outputs=[summary_output, papers_output, year_plot, models_plot, categories_plot]
+            search_and_analyze_vet,
+            inputs=[query_input, max_results, database_choice],
+            outputs=[summary_output, papers_output, year_plot, species_plot, specialties_plot, conditions_plot]
         )
         
         # Add examples
         gr.Examples(
             examples=[
-                ["breast cancer immunotherapy mouse model", 50],
-                ["lung cancer biomarkers xenograft", 30],
-                ["pancreatic cancer treatment PDX", 40],
-                ["melanoma drug resistance animal model", 35]
+                ["canine diabetes insulin therapy", 40, "pubmed"],
+                ["equine lameness diagnosis imaging", 35, "pubmed"],
+                ["feline chronic kidney disease treatment", 45, "pubmed"],
+                ["bovine mastitis antibiotic resistance", 30, "pubmed"],
+                ["avian influenza surveillance wild birds", 35, "pubmed"],
+                ["exotic animal anesthesia protocols", 25, "pubmed"],
+                ["wildlife conservation medicine", 40, "pubmed"],
+                ["small animal oncology chemotherapy", 50, "pubmed"]
             ],
-            inputs=[query_input, max_results]
+            inputs=[query_input, max_results, database_choice]
         )
         
         gr.Markdown("""
-        ### About This Agent
-        This literature mining agent is specifically designed for cancer research in animal models. 
-        It searches PubMed for relevant papers and provides automated analysis of research trends, 
-        commonly used animal models, and emerging therapeutic approaches.
+        ### About This Veterinary Literature Mining Agent
+        
+        This comprehensive tool is designed for veterinary professionals, researchers, and students to efficiently 
+        search and analyze veterinary literature across all animal species and medical specialties.
+        
+        **Supported Areas:**
+        - **Companion Animals**: Dogs, cats, rabbits, ferrets, birds, reptiles, fish
+        - **Large Animals**: Horses, cattle, pigs, sheep, goats
+        - **Wildlife & Zoo Medicine**: All wild species and conservation medicine
+        - **Laboratory Animals**: Research and laboratory animal medicine
+        - **All Veterinary Specialties**: Internal medicine, surgery, oncology, cardiology, dermatology, etc.
         
-        **Data Sources:** PubMed/NCBI databases  
+        **Data Sources:** PubMed/NCBI databases with veterinary focus  
         **Last Updated:** June 2025  
-        **Supported Research Areas:** All cancer types and animal models
+        **Coverage:** All aspects of veterinary medicine and animal health
         """)
     
     return interface
 
 # Create and launch the interface
 if __name__ == "__main__":
-    interface = create_gradio_interface()
+    interface = create_veterinary_gradio_interface()
     interface.launch(
         server_name="0.0.0.0",
         server_port=7860,