updating UI and agent functionality

Author: PranavViswanath

ui/agents/__pycache__/citation_propagator.cpython-313.pyc

@@ -16,10 +16,15 @@
 
 def propagate_citations(contradicted_papers):
     """For each contradicted paper, find recent papers or articles citing it using Perplexity web search."""
+    print(f"🔍 Citation Agent: Received {len(contradicted_papers) if contradicted_papers else 0} papers")
+    print(f"🔍 Citation Agent: Papers data: {contradicted_papers}")
+    
     # Input validation
     if not contradicted_papers or not isinstance(contradicted_papers, list) or len(contradicted_papers) == 0:
+        print("🔍 Citation Agent: No valid papers received")
         return {}
 
+
     try:
         client = OpenAI(api_key=PERPLEXITY_API_KEY, base_url="https://api.perplexity.ai")
         citation_cascades = {}
@@ -39,19 +44,23 @@ def propagate_citations(contradicted_papers):
             )
 
             try:
+                print(f"🔍 Citation Agent: Searching citations for: {paper_title}")
+                # Use same cheap model as agent 1
                 response = client.chat.completions.create(
-                    model="sonar-reasoning",  # Or "sonar-small-chat"; experiment for accuracy
+                    model="sonar",  # Use same model as contradiction detector
                     messages=[
                         {"role": "system", "content": SYSTEM_PROMPT},
                         {"role": "user", "content": f"Find papers citing: {paper_title}"},
                     ],
                     temperature=0.2,
                 )
+                print(f"🔍 Citation Agent: Got response for {paper_title}")
 
                 # Parse the results—these are actual web-search-derived citations
                 citing_papers = []
                 if response.choices and len(response.choices) > 0:
                     content = response.choices[0].message.content
+                    print(f"🔍 Citation Agent: Response content for {paper_title}: {content[:300]}...")
                     if content and "Title:" in content:
                         lines = content.strip().split("\n")
                         for line in lines:
@@ -69,53 +78,30 @@ def propagate_citations(contradicted_papers):
                                     if title:
                                         citing_papers.append(title)
 
-                    # If no papers found, use demo data for this specific paper
+                    # If no papers found, log it but keep empty list
                     if not citing_papers:
-                        if "Large Language Models Still Cannot Plan" in paper_title:
-                            citing_papers = [
-                                "Planning with Large Language Models for Code Generation: Recent Advances and Challenges",
-                                "A Systematic Review of LLM Limitations in Complex Reasoning Tasks", 
-                                "Beyond Pattern Matching: Towards True AI Reasoning Capabilities"
-                            ]
-                        elif "Reasoning Abilities" in paper_title:
-                            citing_papers = [
-                                "Rethinking Evaluation Metrics for Large Language Model Reasoning",
-                                "The Illusion of Understanding in Large Language Models",
-                                "Cognitive Architectures vs. Large Language Models: A Comparative Study"
-                            ]
-                        else:
-                            citing_papers = [
-                                "Emergent Capabilities in AI: Reality or Statistical Artifact?",
-                                "Training Data Memorization vs. Genuine Learning in LLMs",
-                                "Critical Analysis of Emergent Behaviors in Neural Networks"
-                            ]
+                        print(f"⚠️ No citing papers found for: {paper_title}")
 
-                citation_cascades[paper_title] = citing_papers
+                # Remove duplicates from citing papers
+                unique_citing_papers = []
+                seen_papers = set()
+                for paper in citing_papers:
+                    paper_lower = paper.lower().strip()
+                    if paper_lower not in seen_papers:
+                        seen_papers.add(paper_lower)
+                        unique_citing_papers.append(paper)
+                
+                citation_cascades[paper_title] = unique_citing_papers
 
             except Exception as e:
-                print(f"Error processing paper '{paper_title}': {str(e)}")
+                print(f"⚠️ Error processing paper '{paper_title}': {str(e)}")
+                print(f"⚠️ Error type: {type(e)}")
+                print(f"⚠️ Full error details: {repr(e)}")
                 citation_cascades[paper_title] = []
 
         return citation_cascades
 
     except Exception as e:
         print(f"Error in propagate_citations: {str(e)}")
-        # Return demo data for demonstration purposes
-        return {
-            "Large Language Models Still Cannot Plan: A Benchmark Study": [
-                "Planning with Large Language Models for Code Generation: Recent Advances and Challenges",
-                "A Systematic Review of LLM Limitations in Complex Reasoning Tasks",
-                "Beyond Pattern Matching: Towards True AI Reasoning Capabilities"
-            ],
-            "On the Reasoning Abilities of Large Language Models: A Critical Analysis": [
-                "Rethinking Evaluation Metrics for Large Language Model Reasoning",
-                "The Illusion of Understanding in Large Language Models",
-                "Cognitive Architectures vs. Large Language Models: A Comparative Study"
-            ],
-            "Emergent Abilities of Large Language Models Are Not What They Seem": [
-                "Emergent Capabilities in AI: Reality or Statistical Artifact?",
-                "Training Data Memorization vs. Genuine Learning in LLMs",
-                "Critical Analysis of Emergent Behaviors in Neural Networks"
-            ]
-        }
+        return {}
 

ui/agents/__pycache__/contradiction_detector.cpython-313.pyc

@@ -30,89 +30,74 @@ def detect_contradictions(claim: str) -> list:
         # Craft a prompt to find scientific papers that contradict your claim.
         # Perplexity will do live web search and extract sources.
         SYSTEM_PROMPT = (
-            "You are an expert scientific researcher. Identify recent academic papers or "
-            "articles that directly address or contradict the following research claim. "
-            "For each, provide the title and a brief excerpt supporting the contradiction. "
-            "Only include papers found via real-time web search. Format each as: "
-            "Title: [title] | Excerpt: [relevant text]"
+            "Find academic papers that contradict this research claim. "
+            "For each paper, respond with exactly this format:\n"
+            "PAPER 1:\n"
+            "Title: [paper title]\n"
+            "Excerpt: [contradiction excerpt]\n\n"
+            "PAPER 2:\n"
+            "Title: [paper title]\n"
+            "Excerpt: [contradiction excerpt]\n\n"
+            "Find at least 2-3 papers that challenge this claim."
         )
 
         response = client.chat.completions.create(
-            model="sonar-reasoning",  # Uses Perplexity's real-time web search model
+            model="sonar",  # Use fastest, cheapest model
             messages=[
                 {"role": "system", "content": SYSTEM_PROMPT},
                 {"role": "user", "content": claim},
             ],
             temperature=0.2,
         )
 
-        # Parse the results—these are actual web-search-derived contradictions.
+        # Parse the results with simpler logic
         results = []
         if response.choices and len(response.choices) > 0:
             content = response.choices[0].message.content
-            if content and "Title:" in content:
-                # Split by lines and process each title/excerpt pair
-                lines = content.strip().split("\n")
-                current_title = ""
-                current_excerpt = ""
-                
+            print(f"🔍 Contradiction response: {content[:300]}...")
+            
+            if content:
+                # Split by PAPER sections
+                papers = content.split("PAPER")
+                for paper_section in papers:
+                    if "Title:" in paper_section and "Excerpt:" in paper_section:
+                        lines = paper_section.strip().split("\n")
+                        title = ""
+                        excerpt = ""
+                        
+                        for line in lines:
+                            if line.startswith("Title:"):
+                                title = line.replace("Title:", "").strip()
+                            elif line.startswith("Excerpt:"):
+                                excerpt = line.replace("Excerpt:", "").strip()
+                        
+                        if title and excerpt:
+                            results.append({"title": title, "excerpt": excerpt})
+            
+            # If still no results, try basic parsing
+            if not results and "Title:" in content:
+                lines = content.split("\n")
                 for line in lines:
-                    line = line.strip()
-                    if line.startswith("Title:"):
-                        # Save previous entry if exists
-                        if current_title:
-                            results.append({"title": current_title, "excerpt": current_excerpt})
-                        # Start new entry
-                        if "| Excerpt:" in line:
-                            parts = line.split("| Excerpt:")
-                            current_title = parts[0].replace("Title:", "").strip()
-                            current_excerpt = parts[1].strip() if len(parts) > 1 else ""
-                        else:
-                            current_title = line.replace("Title:", "").strip()
-                            current_excerpt = ""
-                    elif line.startswith("Excerpt:") or (current_title and line and not line.startswith("Title:")):
-                        if line.startswith("Excerpt:"):
-                            current_excerpt = line.replace("Excerpt:", "").strip()
-                        else:
-                            current_excerpt += " " + line
-                
-                # Don't forget the last entry
-                if current_title:
-                    results.append({"title": current_title, "excerpt": current_excerpt})
+                    if line.startswith("Title:") or "Title:" in line:
+                        # Simple extraction
+                        title = line.split("Title:")[-1].strip()
+                        if title:
+                            results.append({"title": title, "excerpt": "Contradictory evidence found"})
 
-            # If no proper parsing worked, fallback to demo data  
             if not results:
-                results = [
-                    {
-                        "title": "Large Language Models Still Cannot Plan: A Benchmark Study",
-                        "excerpt": "Despite recent advances, our comprehensive evaluation shows that current LLMs exhibit significant limitations in multi-step reasoning and planning tasks, contradicting claims about their reasoning capabilities."
-                    },
-                    {
-                        "title": "On the Reasoning Abilities of Large Language Models: A Critical Analysis", 
-                        "excerpt": "We demonstrate through systematic testing that LLMs primarily rely on pattern matching rather than genuine logical reasoning, revealing fundamental gaps in their cognitive abilities."
-                    },
-                    {
-                        "title": "Emergent Abilities of Large Language Models Are Not What They Seem",
-                        "excerpt": "Our analysis suggests that apparent reasoning capabilities in LLMs are largely artifacts of training data memorization rather than true emergent reasoning abilities."
-                    }
-                ]
+                print(f"⚠️ Could not parse contradictions from response: {content[:500]}...")
 
-        return results
+        # Remove duplicates based on title
+        unique_results = []
+        seen_titles = set()
+        for paper in results:
+            title_lower = paper['title'].lower().strip()
+            if title_lower not in seen_titles:
+                seen_titles.add(title_lower)
+                unique_results.append(paper)
+        
+        return unique_results
 
     except Exception as e:
         print(f"Error in detect_contradictions: {str(e)}")
-        # Return demo data for demonstration purposes
-        return [
-            {
-                "title": "Large Language Models Still Cannot Plan: A Benchmark Study",
-                "excerpt": "Despite recent advances, our comprehensive evaluation shows that current LLMs exhibit significant limitations in multi-step reasoning and planning tasks, contradicting claims about their reasoning capabilities."
-            },
-            {
-                "title": "On the Reasoning Abilities of Large Language Models: A Critical Analysis",
-                "excerpt": "We demonstrate through systematic testing that LLMs primarily rely on pattern matching rather than genuine logical reasoning, revealing fundamental gaps in their cognitive abilities."
-            },
-            {
-                "title": "Emergent Abilities of Large Language Models Are Not What They Seem",
-                "excerpt": "Our analysis suggests that apparent reasoning capabilities in LLMs are largely artifacts of training data memorization rather than true emergent reasoning abilities."
-            }
-        ]
+        return []

ui/agents/__pycache__/severity_assessor.cpython-313.pyc

@@ -71,13 +71,12 @@ def generate_synthesis(claim, contradicted_papers, citation_cascades):
         )
 
         response = client.chat.completions.create(
-            model="sonar",  # Try the basic sonar model first
+            model="sonar",  # Use same model as other agents
             messages=[
                 {"role": "system", "content": SYSTEM_PROMPT},
                 {"role": "user", "content": user_prompt},
             ],
             temperature=0.1,
-            max_tokens=250
         )
 
         # Clean the response aggressively to remove thinking process
@@ -100,12 +99,4 @@ def generate_synthesis(claim, contradicted_papers, citation_cascades):
 
     except Exception as e:
         print(f"Error in generate_synthesis: {str(e)}")
-        return """Based on these contradictory findings, there are several research directions to consider:
-
-• **Experimental Validation**: Design controlled experiments to test the specific claims made in your research against the contradictory evidence found
-
-• **Methodological Comparison**: Compare your methodology with the approaches used in the contradictory papers to identify key differences 
-
-• **Gap Analysis**: Focus on the specific gaps or limitations highlighted by the contradictory research to refine your approach
-
-Good luck!"""
+        return "Unable to generate research strategy. Please try again."

ui/agents/citation_propagator.py

@@ -66,16 +66,16 @@ async def root():
     return {"message": "Research Integrity Network API is running"}
 
 @app.post("/extract_text", response_model=TextExtractionResponse)
-async def extract_text_from_pdf(pdf_file: UploadFile = File(...)):
+async def extract_text_from_pdf(file: UploadFile = File(...)):
     """
     Extract text from uploaded PDF file
     """
     try:
-        if not pdf_file.filename.lower().endswith('.pdf'):
+        if not file.filename or not file.filename.lower().endswith('.pdf'):
             raise HTTPException(status_code=400, detail="File must be a PDF")
 
         # Read the PDF file
-        pdf_content = await pdf_file.read()
+        pdf_content = await file.read()
         pdf_reader = PdfReader(io.BytesIO(pdf_content))
 
         # Extract text from all pages
@@ -161,5 +161,5 @@ async def analyze_claim_endpoint(request: AnalyzeRequest):
         raise HTTPException(status_code=500, detail=f"Error analyzing claim: {str(e)}")
 
 if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=8502)
+    uvicorn.run(app, host="0.0.0.0", port=8501)