aiagents4pharma 1.9.0__py3-none-any.whl → 1.10.0__py3-none-any.whl

aiagents4pharma/__init__.py

@@ -1,8 +1,11 @@
-'''
+"""
 This file is used to import aiagents4pharma modules.
-'''
+"""
 
-from . import talk2biomodels
-from . import talk2cells
-from . import talk2knowledgegraphs
-from . import configs
+from . import (
+    configs,
+    talk2biomodels,
+    talk2cells,
+    talk2competitors,
+    talk2knowledgegraphs,
+)

aiagents4pharma/talk2competitors/__init__.py

@@ -0,0 +1,5 @@
+"""
+This file is used to import all the modules in the package.
+"""
+
+from . import agents, config, state, tests, tools

aiagents4pharma/talk2competitors/agents/__init__.py

@@ -0,0 +1,6 @@
+'''
+This file is used to import all the modules in the package.
+'''
+
+from . import main_agent
+from . import s2_agent

aiagents4pharma/talk2competitors/agents/main_agent.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+
+"""
+Main agent for the talk2competitors app.
+"""
+
+import logging
+from typing import Literal
+from dotenv import load_dotenv
+from langchain_core.language_models.chat_models import BaseChatModel
+from langchain_core.messages import AIMessage
+from langchain_openai import ChatOpenAI
+from langgraph.checkpoint.memory import MemorySaver
+from langgraph.graph import END, START, StateGraph
+from langgraph.types import Command
+from ..agents import s2_agent
+from ..config.config import config
+from ..state.state_talk2competitors import Talk2Competitors
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+load_dotenv()
+
+def make_supervisor_node(llm: BaseChatModel) -> str:
+    """
+    Creates a supervisor node following LangGraph patterns.
+
+    Args:
+        llm (BaseChatModel): The language model to use for generating responses.
+
+    Returns:
+        str: The supervisor node function.
+    """
+    # options = ["FINISH", "s2_agent"]
+
+    def supervisor_node(state: Talk2Competitors) -> Command[Literal["s2_agent", "__end__"]]:
+        """
+        Supervisor node that routes to appropriate sub-agents.
+
+        Args:
+            state (Talk2Competitors): The current state of the conversation.
+
+        Returns:
+            Command[Literal["s2_agent", "__end__"]]: The command to execute next.
+        """
+        logger.info("Supervisor node called")
+
+        messages = [{"role": "system", "content": config.MAIN_AGENT_PROMPT}] + state[
+            "messages"
+        ]
+        response = llm.invoke(messages)
+        goto = (
+            "FINISH"
+            if not any(
+                kw in state["messages"][-1].content.lower()
+                for kw in ["search", "paper", "find"]
+            )
+            else "s2_agent"
+        )
+
+        if goto == "FINISH":
+            return Command(
+                goto=END,
+                update={
+                    "messages": state["messages"]
+                    + [AIMessage(content=response.content)],
+                    "is_last_step": True,
+                    "current_agent": None,
+                },
+            )
+
+        return Command(
+            goto="s2_agent",
+            update={
+                "messages": state["messages"],
+                "is_last_step": False,
+                "current_agent": "s2_agent",
+            },
+        )
+
+    return supervisor_node
+
+def get_app(thread_id: str, llm_model ='gpt-4o-mini') -> StateGraph:
+    """
+    Returns the langraph app with hierarchical structure.
+
+    Args:
+        thread_id (str): The thread ID for the conversation.
+
+    Returns:
+        The compiled langraph app.
+    """
+    def call_s2_agent(state: Talk2Competitors) -> Command[Literal["__end__"]]:
+        """
+        Node for calling the S2 agent.
+
+        Args:
+            state (Talk2Competitors): The current state of the conversation.
+
+        Returns:
+            Command[Literal["__end__"]]: The command to execute next.
+        """
+        logger.info("Calling S2 agent")
+        app = s2_agent.get_app(thread_id, llm_model)
+        response = app.invoke(state)
+        logger.info("S2 agent completed")
+        return Command(
+            goto=END,
+            update={
+                "messages": response["messages"],
+                "papers": response.get("papers", []),
+                "is_last_step": True,
+                "current_agent": "s2_agent",
+            },
+        )
+    llm = ChatOpenAI(model=llm_model, temperature=0)
+    workflow = StateGraph(Talk2Competitors)
+
+    supervisor = make_supervisor_node(llm)
+    workflow.add_node("supervisor", supervisor)
+    workflow.add_node("s2_agent", call_s2_agent)
+
+    # Define edges
+    workflow.add_edge(START, "supervisor")
+    workflow.add_edge("s2_agent", END)
+
+    app = workflow.compile(checkpointer=MemorySaver())
+    logger.info("Main agent workflow compiled")
+    return app

aiagents4pharma/talk2competitors/agents/s2_agent.py

@@ -0,0 +1,75 @@
+#/usr/bin/env python3
+
+'''
+Agent for interacting with Semantic Scholar
+'''
+
+import logging
+from dotenv import load_dotenv
+from langchain_openai import ChatOpenAI
+from langgraph.graph import START, StateGraph
+from langgraph.prebuilt import create_react_agent
+from langgraph.checkpoint.memory import MemorySaver
+from ..config.config import config
+from ..state.state_talk2competitors import Talk2Competitors
+# from ..tools.s2 import s2_tools
+from ..tools.s2.search import search_tool
+from ..tools.s2.display_results import display_results
+from ..tools.s2.single_paper_rec import get_single_paper_recommendations
+from ..tools.s2.multi_paper_rec import get_multi_paper_recommendations
+
+load_dotenv()
+
+# Initialize logger
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def get_app(uniq_id, llm_model='gpt-4o-mini'):
+    '''
+    This function returns the langraph app.
+    '''
+    def agent_s2_node(state: Talk2Competitors):
+        '''
+        This function calls the model.
+        '''
+        logger.log(logging.INFO, "Creating Agent_S2 node with thread_id %s", uniq_id)
+        response = model.invoke(state, {"configurable": {"thread_id": uniq_id}})
+        return response
+
+    # Define the tools
+    tools = [search_tool,
+            display_results,
+            get_single_paper_recommendations,
+            get_multi_paper_recommendations]
+
+    # Create the LLM
+    llm = ChatOpenAI(model=llm_model, temperature=0)
+    model = create_react_agent(
+                            llm,
+                            tools=tools,
+                            state_schema=Talk2Competitors,
+                            state_modifier=config.S2_AGENT_PROMPT,
+                            checkpointer=MemorySaver()
+                        )
+
+    # Define a new graph
+    workflow = StateGraph(Talk2Competitors)
+
+    # Define the two nodes we will cycle between
+    workflow.add_node("agent_s2", agent_s2_node)
+
+    # Set the entrypoint as `agent`
+    # This means that this node is the first one called
+    workflow.add_edge(START, "agent_s2")
+
+    # Initialize memory to persist state between graph runs
+    checkpointer = MemorySaver()
+
+    # Finally, we compile it!
+    # This compiles it into a LangChain Runnable,
+    # meaning you can use it as you would any other runnable.
+    # Note that we're (optionally) passing the memory when compiling the graph
+    app = workflow.compile(checkpointer=checkpointer)
+    logger.log(logging.INFO, "Compiled the graph")
+
+    return app

aiagents4pharma/talk2competitors/config/__init__.py

@@ -0,0 +1,5 @@
+"""
+This package contains configuration settings and prompts used by various AI agents
+"""
+
+from . import config

aiagents4pharma/talk2competitors/config/config.py

@@ -0,0 +1,110 @@
+"""Configuration module for AI agents handling paper searches and recommendations."""
+
+
+# pylint: disable=R0903
+class Config:
+    """Configuration class containing prompts for AI agents.
+
+    This class stores prompt templates used by various AI agents in the system,
+    particularly for academic paper searches and recommendations.
+    """
+
+    MAIN_AGENT_PROMPT = (
+        "You are a supervisory AI agent that routes user queries to specialized tools.\n"
+        "Your task is to select the most appropriate tool based on the user's request.\n\n"
+        "Available tools and their capabilities:\n\n"
+        "1. semantic_scholar_agent:\n"
+        "   - Search for academic papers and research\n"
+        "   - Get paper recommendations\n"
+        "   - Find similar papers\n"
+        "   USE FOR: Any queries about finding papers, academic research, "
+        "or getting paper recommendations\n\n"
+        "ROUTING GUIDELINES:\n\n"
+        "ALWAYS route to semantic_scholar_agent for:\n"
+        "- Finding academic papers\n"
+        "- Searching research topics\n"
+        "- Getting paper recommendations\n"
+        "- Finding similar papers\n"
+        "- Any query about academic literature\n\n"
+        "Approach:\n"
+        "1. Identify the core need in the user's query\n"
+        "2. Select the most appropriate tool based on the guidelines above\n"
+        "3. If unclear, ask for clarification\n"
+        "4. For multi-step tasks, focus on the immediate next step\n\n"
+        "Remember:\n"
+        "- Be decisive in your tool selection\n"
+        "- Focus on the immediate task\n"
+        "- Default to semantic_scholar_agent for any paper-finding tasks\n"
+        "- Ask for clarification if the request is ambiguous\n\n"
+        "When presenting paper search results, always use this exact format:\n\n"
+        "Remember to:\n"
+        "- Always remember to add the url\n"
+        "- Put URLs on the title line itself as markdown\n"
+        "- Maintain consistent spacing and formatting"
+    )
+
+    S2_AGENT_PROMPT = (
+        "You are a specialized academic research assistant with access to the following tools:\n\n"
+        "1. search_papers:\n"
+        "   USE FOR: General paper searches\n"
+        "   - Enhances search terms automatically\n"
+        "   - Adds relevant academic keywords\n"
+        "   - Focuses on recent research when appropriate\n\n"
+        "2. get_single_paper_recommendations:\n"
+        "   USE FOR: Finding papers similar to a specific paper\n"
+        "   - Takes a single paper ID\n"
+        "   - Returns related papers\n\n"
+        "3. get_multi_paper_recommendations:\n"
+        "   USE FOR: Finding papers similar to multiple papers\n"
+        "   - Takes multiple paper IDs\n"
+        "   - Finds papers related to all inputs\n\n"
+        "GUIDELINES:\n\n"
+        "For paper searches:\n"
+        "- Enhance search terms with academic language\n"
+        "- Include field-specific terminology\n"
+        '- Add "recent" or "latest" when appropriate\n'
+        "- Keep queries focused and relevant\n\n"
+        "For paper recommendations:\n"
+        "- Identify paper IDs (40-character hexadecimal strings)\n"
+        "- Use single_paper_recommendations for one ID\n"
+        "- Use multi_paper_recommendations for multiple IDs\n\n"
+        "Best practices:\n"
+        "1. Start with a broad search if no paper IDs are provided\n"
+        "2. Look for paper IDs in user input\n"
+        "3. Enhance search terms for better results\n"
+        "4. Consider the academic context\n"
+        "5. Be prepared to refine searches based on feedback\n\n"
+        "Remember:\n"
+        "- Always select the most appropriate tool\n"
+        "- Enhance search queries naturally\n"
+        "- Consider academic context\n"
+        "- Focus on delivering relevant results\n\n"
+        "IMPORTANT GUIDELINES FOR PAPER RECOMMENDATIONS:\n\n"
+        "For Multiple Papers:\n"
+        "- When getting recommendations for multiple papers, always use "
+        "get_multi_paper_recommendations tool\n"
+        "- DO NOT call get_single_paper_recommendations multiple times\n"
+        "- Always pass all paper IDs in a single call to get_multi_paper_recommendations\n"
+        '- Use for queries like "find papers related to both/all papers" or '
+        '"find similar papers to these papers"\n\n'
+        "For Single Paper:\n"
+        "- Use get_single_paper_recommendations when focusing on one specific paper\n"
+        "- Pass only one paper ID at a time\n"
+        '- Use for queries like "find papers similar to this paper" or '
+        '"get recommendations for paper X"\n'
+        "- Do not use for multiple papers\n\n"
+        "Examples:\n"
+        '- For "find related papers for both papers":\n'
+        "  ✓ Use get_multi_paper_recommendations with both paper IDs\n"
+        "  × Don't make multiple calls to get_single_paper_recommendations\n\n"
+        '- For "find papers related to the first paper":\n'
+        "  ✓ Use get_single_paper_recommendations with just that paper's ID\n"
+        "  × Don't use get_multi_paper_recommendations\n\n"
+        "Remember:\n"
+        "- Be precise in identifying which paper ID to use for single recommendations\n"
+        "- Don't reuse previous paper IDs unless specifically requested\n"
+        "- For fresh paper recommendations, always use the original paper ID"
+    )
+
+
+config = Config()

aiagents4pharma/talk2competitors/state/__init__.py

@@ -0,0 +1,5 @@
+'''
+This file is used to import all the modules in the package.
+'''
+
+from . import state_talk2competitors

aiagents4pharma/talk2competitors/state/state_talk2competitors.py

@@ -0,0 +1,32 @@
+"""
+This is the state file for the talk2comp agent.
+"""
+
+import logging
+from typing import Annotated, Any, Dict, Optional
+
+from langgraph.prebuilt.chat_agent_executor import AgentState
+from typing_extensions import NotRequired, Required
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def replace_dict(existing: Dict[str, Any], new: Dict[str, Any]) -> Dict[str, Any]:
+    """Replace the existing dict with the new one."""
+    logger.info("Updating existing state %s with the state dict: %s", existing, new)
+    return new
+
+
+class Talk2Competitors(AgentState):
+    """
+    The state for the talk2comp agent, inheriting from AgentState.
+    """
+
+    papers: Annotated[Dict[str, Any], replace_dict]  # Changed from List to Dict
+    search_table: NotRequired[str]
+    next: str  # Required for routing in LangGraph
+    current_agent: NotRequired[Optional[str]]
+    is_last_step: Required[bool]  # Required field for LangGraph
+    llm_model: str

aiagents4pharma/talk2competitors/tests/__init__.py

@@ -0,0 +1,3 @@
+"""
+This module contains the test cases.
+"""

aiagents4pharma/talk2competitors/tests/test_langgraph.py

@@ -0,0 +1,274 @@
+"""
+Unit and integration tests for Talk2Competitors system.
+Each test focuses on a single, specific functionality.
+Tests are deterministic and independent of each other.
+"""
+
+from unittest.mock import Mock, patch
+
+import pytest
+from langchain_core.messages import AIMessage, HumanMessage
+
+from ..agents.main_agent import get_app, make_supervisor_node
+from ..state.state_talk2competitors import replace_dict
+from ..tools.s2.display_results import display_results
+from ..tools.s2.multi_paper_rec import get_multi_paper_recommendations
+from ..tools.s2.search import search_tool
+from ..tools.s2.single_paper_rec import get_single_paper_recommendations
+
+# pylint: disable=redefined-outer-name
+
+# Fixed test data for deterministic results
+MOCK_SEARCH_RESPONSE = {
+    "data": [
+        {
+            "paperId": "123",
+            "title": "Machine Learning Basics",
+            "abstract": "An introduction to ML",
+            "year": 2023,
+            "citationCount": 100,
+            "url": "https://example.com/paper1",
+            "authors": [{"name": "Test Author"}],
+        }
+    ]
+}
+
+MOCK_STATE_PAPER = {
+    "123": {
+        "Title": "Machine Learning Basics",
+        "Abstract": "An introduction to ML",
+        "Year": 2023,
+        "Citation Count": 100,
+        "URL": "https://example.com/paper1",
+    }
+}
+
+
+@pytest.fixture
+def initial_state():
+    """Create a base state for tests"""
+    return {
+        "messages": [],
+        "papers": {},
+        "is_last_step": False,
+        "current_agent": None,
+        "llm_model": "gpt-4o-mini",
+    }
+
+
+class TestMainAgent:
+    """Unit tests for main agent functionality"""
+
+    def test_supervisor_routes_search_to_s2(self, initial_state):
+        """Verifies that search-related queries are routed to S2 agent"""
+        llm_mock = Mock()
+        llm_mock.invoke.return_value = AIMessage(content="Search initiated")
+
+        supervisor = make_supervisor_node(llm_mock)
+        state = initial_state.copy()
+        state["messages"] = [HumanMessage(content="search for papers")]
+
+        result = supervisor(state)
+        assert result.goto == "s2_agent"
+        assert not result.update["is_last_step"]
+        assert result.update["current_agent"] == "s2_agent"
+
+    def test_supervisor_routes_general_to_end(self, initial_state):
+        """Verifies that non-search queries end the conversation"""
+        llm_mock = Mock()
+        llm_mock.invoke.return_value = AIMessage(content="General response")
+
+        supervisor = make_supervisor_node(llm_mock)
+        state = initial_state.copy()
+        state["messages"] = [HumanMessage(content="What is ML?")]
+
+        result = supervisor(state)
+        assert result.goto == "__end__"
+        assert result.update["is_last_step"]
+
+
+class TestS2Tools:
+    """Unit tests for individual S2 tools"""
+
+    def test_display_results_shows_papers(self, initial_state):
+        """Verifies display_results tool correctly returns papers from state"""
+        state = initial_state.copy()
+        state["papers"] = MOCK_STATE_PAPER
+        result = display_results.invoke(input={"state": state})
+        assert result == MOCK_STATE_PAPER
+        assert isinstance(result, dict)
+
+    @patch("requests.get")
+    def test_search_finds_papers(self, mock_get):
+        """Verifies search tool finds and formats papers correctly"""
+        mock_get.return_value.json.return_value = MOCK_SEARCH_RESPONSE
+        mock_get.return_value.status_code = 200
+
+        result = search_tool.invoke(
+            input={
+                "query": "machine learning",
+                "limit": 1,
+                "tool_call_id": "test123",
+                "id": "test123",
+            }
+        )
+
+        assert "papers" in result.update
+        assert "messages" in result.update
+        papers = result.update["papers"]
+        assert isinstance(papers, dict)
+        assert len(papers) > 0
+        paper = next(iter(papers.values()))
+        assert paper["Title"] == "Machine Learning Basics"
+        assert paper["Year"] == 2023
+
+    @patch("requests.get")
+    def test_single_paper_rec_basic(self, mock_get):
+        """Tests basic single paper recommendation functionality"""
+        mock_get.return_value.json.return_value = {
+            "recommendedPapers": [MOCK_SEARCH_RESPONSE["data"][0]]
+        }
+        mock_get.return_value.status_code = 200
+
+        result = get_single_paper_recommendations.invoke(
+            input={
+                "paper_id": "123",
+                "limit": 1,
+                "tool_call_id": "test123",
+                "id": "test123",
+            }
+        )
+        assert "papers" in result.update
+        assert len(result.update["messages"]) == 1
+
+    @patch("requests.get")
+    def test_single_paper_rec_with_optional_params(self, mock_get):
+        """Tests single paper recommendations with year parameter"""
+        mock_get.return_value.json.return_value = {
+            "recommendedPapers": [MOCK_SEARCH_RESPONSE["data"][0]]
+        }
+        mock_get.return_value.status_code = 200
+
+        result = get_single_paper_recommendations.invoke(
+            input={
+                "paper_id": "123",
+                "limit": 1,
+                "year": "2023-",
+                "tool_call_id": "test123",
+                "id": "test123",
+            }
+        )
+        assert "papers" in result.update
+
+    @patch("requests.post")
+    def test_multi_paper_rec_basic(self, mock_post):
+        """Tests basic multi-paper recommendation functionality"""
+        mock_post.return_value.json.return_value = {
+            "recommendedPapers": [MOCK_SEARCH_RESPONSE["data"][0]]
+        }
+        mock_post.return_value.status_code = 200
+
+        result = get_multi_paper_recommendations.invoke(
+            input={
+                "paper_ids": ["123", "456"],
+                "limit": 1,
+                "tool_call_id": "test123",
+                "id": "test123",
+            }
+        )
+        assert "papers" in result.update
+        assert len(result.update["messages"]) == 1
+
+    @patch("requests.post")
+    def test_multi_paper_rec_with_optional_params(self, mock_post):
+        """Tests multi-paper recommendations with all optional parameters"""
+        mock_post.return_value.json.return_value = {
+            "recommendedPapers": [MOCK_SEARCH_RESPONSE["data"][0]]
+        }
+        mock_post.return_value.status_code = 200
+
+        result = get_multi_paper_recommendations.invoke(
+            input={
+                "paper_ids": ["123", "456"],
+                "limit": 1,
+                "year": "2023-",
+                "tool_call_id": "test123",
+                "id": "test123",
+            }
+        )
+        assert "papers" in result.update
+        assert len(result.update["messages"]) == 1
+
+    @patch("requests.get")
+    def test_single_paper_rec_empty_response(self, mock_get):
+        """Tests single paper recommendations with empty response"""
+        mock_get.return_value.json.return_value = {"recommendedPapers": []}
+        mock_get.return_value.status_code = 200
+
+        result = get_single_paper_recommendations.invoke(
+            input={
+                "paper_id": "123",
+                "limit": 1,
+                "tool_call_id": "test123",
+                "id": "test123",
+            }
+        )
+        assert "papers" in result.update
+        assert len(result.update["papers"]) == 0
+
+    @patch("requests.post")
+    def test_multi_paper_rec_empty_response(self, mock_post):
+        """Tests multi-paper recommendations with empty response"""
+        mock_post.return_value.json.return_value = {"recommendedPapers": []}
+        mock_post.return_value.status_code = 200
+
+        result = get_multi_paper_recommendations.invoke(
+            input={
+                "paper_ids": ["123", "456"],
+                "limit": 1,
+                "tool_call_id": "test123",
+                "id": "test123",
+            }
+        )
+        assert "papers" in result.update
+        assert len(result.update["papers"]) == 0
+
+
+def test_state_replace_dict():
+    """Verifies state dictionary replacement works correctly"""
+    existing = {"key1": "value1", "key2": "value2"}
+    new = {"key3": "value3"}
+    result = replace_dict(existing, new)
+    assert result == new
+    assert isinstance(result, dict)
+
+
+@pytest.mark.integration
+def test_end_to_end_search_workflow(initial_state):
+    """Integration test: Complete search workflow"""
+    with (
+        patch("requests.get") as mock_get,
+        patch("langchain_openai.ChatOpenAI") as mock_llm,
+    ):
+        mock_get.return_value.json.return_value = MOCK_SEARCH_RESPONSE
+        mock_get.return_value.status_code = 200
+
+        llm_instance = Mock()
+        llm_instance.invoke.return_value = AIMessage(content="Search completed")
+        mock_llm.return_value = llm_instance
+
+        app = get_app("test_integration")
+        test_state = initial_state.copy()
+        test_state["messages"] = [HumanMessage(content="search for ML papers")]
+
+        config = {
+            "configurable": {
+                "thread_id": "test_integration",
+                "checkpoint_ns": "test",
+                "checkpoint_id": "test123",
+            }
+        }
+
+        response = app.invoke(test_state, config)
+        assert "papers" in response
+        assert len(response["messages"]) > 0

aiagents4pharma/talk2competitors/tools/__init__.py

@@ -0,0 +1,7 @@
+#!/usr/bin/env python3
+
+'''
+Import statements
+'''
+
+from . import s2

aiagents4pharma/talk2competitors/tools/s2/__init__.py

@@ -0,0 +1,8 @@
+'''
+This file is used to import all the modules in the package.
+'''
+
+from . import display_results
+from . import multi_paper_rec
+from . import search
+from . import single_paper_rec

aiagents4pharma/talk2competitors/tools/s2/display_results.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+
+'''
+This tool is used to display the table of studies.
+'''
+
+import logging
+from typing import Annotated
+from langchain_core.tools import tool
+from langgraph.prebuilt import InjectedState
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+@tool('display_results')
+def display_results(state: Annotated[dict, InjectedState]):
+    """
+    Display the papers in the state.
+
+    Args:
+        state (dict): The state of the agent.
+    """
+    logger.info("Displaying papers from the state")
+    return state["papers"]

aiagents4pharma/talk2competitors/tools/s2/multi_paper_rec.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+
+"""
+multi_paper_rec: Tool for getting recommendations
+                based on multiple papers
+"""
+
+import json
+import logging
+from typing import Annotated, Any, Dict, List, Optional
+
+import pandas as pd
+import requests
+from langchain_core.messages import ToolMessage
+from langchain_core.tools import tool
+from langchain_core.tools.base import InjectedToolCallId
+from langgraph.types import Command
+from pydantic import BaseModel, Field
+
+
+class MultiPaperRecInput(BaseModel):
+    """Input schema for multiple paper recommendations tool."""
+
+    paper_ids: List[str] = Field(
+        description=("List of Semantic Scholar Paper IDs to get recommendations for")
+    )
+    limit: int = Field(
+        default=2,
+        description="Maximum total number of recommendations to return",
+        ge=1,
+        le=500,
+    )
+    year: Optional[str] = Field(
+        default=None,
+        description="Year range in format: YYYY for specific year, "
+        "YYYY- for papers after year, -YYYY for papers before year, or YYYY:YYYY for range",
+    )
+    tool_call_id: Annotated[str, InjectedToolCallId]
+
+    model_config = {"arbitrary_types_allowed": True}
+
+
+@tool(args_schema=MultiPaperRecInput)
+def get_multi_paper_recommendations(
+    paper_ids: List[str],
+    tool_call_id: Annotated[str, InjectedToolCallId],
+    limit: int = 2,
+    year: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Get paper recommendations based on multiple papers.
+
+    Args:
+        paper_ids (List[str]): The list of paper IDs to base recommendations on.
+        tool_call_id (Annotated[str, InjectedToolCallId]): The tool call ID.
+        limit (int, optional): The maximum number of recommendations to return. Defaults to 2.
+        year (str, optional): Year range for papers.
+        Supports formats like "2024-", "-2024", "2024:2025". Defaults to None.
+
+    Returns:
+        Dict[str, Any]: The recommendations and related information.
+    """
+    logging.info("Starting multi-paper recommendations search.")
+
+    endpoint = "https://api.semanticscholar.org/recommendations/v1/papers"
+    headers = {"Content-Type": "application/json"}
+    payload = {"positivePaperIds": paper_ids, "negativePaperIds": []}
+    params = {
+        "limit": min(limit, 500),
+        "fields": "paperId,title,abstract,year,authors,citationCount,url",
+    }
+
+    # Add year parameter if provided
+    if year:
+        params["year"] = year
+
+    # Getting recommendations
+    response = requests.post(
+        endpoint,
+        headers=headers,
+        params=params,
+        data=json.dumps(payload),
+        timeout=10,
+    )
+    logging.info(
+        "API Response Status for multi-paper recommendations: %s", response.status_code
+    )
+
+    data = response.json()
+    recommendations = data.get("recommendedPapers", [])
+
+    # Create a dictionary to store the papers
+    filtered_papers = {
+        paper["paperId"]: {
+            "Title": paper.get("title", "N/A"),
+            "Abstract": paper.get("abstract", "N/A"),
+            "Year": paper.get("year", "N/A"),
+            "Citation Count": paper.get("citationCount", "N/A"),
+            "URL": paper.get("url", "N/A"),
+        }
+        for paper in recommendations
+        if paper.get("title") and paper.get("paperId")
+    }
+
+    # Create a DataFrame from the dictionary
+    df = pd.DataFrame.from_dict(filtered_papers, orient="index")
+    # print("Created DataFrame with results:")
+    logging.info("Created DataFrame with results: %s", df)
+
+    # Format papers for state update
+    papers = [
+        f"Paper ID: {paper_id}\n"
+        f"Title: {paper_data['Title']}\n"
+        f"Abstract: {paper_data['Abstract']}\n"
+        f"Year: {paper_data['Year']}\n"
+        f"Citations: {paper_data['Citation Count']}\n"
+        f"URL: {paper_data['URL']}\n"
+        for paper_id, paper_data in filtered_papers.items()
+    ]
+
+    # Convert DataFrame to markdown table
+    markdown_table = df.to_markdown(tablefmt="grid")
+    logging.info("Search results: %s", papers)
+
+    return Command(
+        update={
+            "papers": filtered_papers,  # Now sending the dictionary directly
+            "messages": [
+                ToolMessage(content=markdown_table, tool_call_id=tool_call_id)
+            ],
+        }
+    )

aiagents4pharma/talk2competitors/tools/s2/search.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+
+"""
+This tool is used to search for academic papers on Semantic Scholar.
+"""
+
+import logging
+from typing import Annotated, Any, Dict, Optional
+
+import pandas as pd
+import requests
+from langchain_core.messages import ToolMessage
+from langchain_core.tools import tool
+from langchain_core.tools.base import InjectedToolCallId
+from langgraph.types import Command
+from pydantic import BaseModel, Field
+
+
+class SearchInput(BaseModel):
+    """Input schema for the search papers tool."""
+
+    query: str = Field(
+        description="Search query string to find academic papers."
+        "Be specific and include relevant academic terms."
+    )
+    limit: int = Field(
+        default=2, description="Maximum number of results to return", ge=1, le=100
+    )
+    year: Optional[str] = Field(
+        default=None,
+        description="Year range in format: YYYY for specific year, "
+        "YYYY- for papers after year, -YYYY for papers before year, or YYYY:YYYY for range",
+    )
+    tool_call_id: Annotated[str, InjectedToolCallId]
+
+
+@tool(args_schema=SearchInput)
+def search_tool(
+    query: str,
+    tool_call_id: Annotated[str, InjectedToolCallId],
+    limit: int = 2,
+    year: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Search for academic papers on Semantic Scholar.
+
+    Args:
+        query (str): The search query string to find academic papers.
+        tool_call_id (Annotated[str, InjectedToolCallId]): The tool call ID.
+        limit (int, optional): The maximum number of results to return. Defaults to 2.
+        year (str, optional): Year range for papers.
+        Supports formats like "2024-", "-2024", "2024:2025". Defaults to None.
+
+    Returns:
+        Dict[str, Any]: The search results and related information.
+    """
+    print("Starting paper search...")
+    endpoint = "https://api.semanticscholar.org/graph/v1/paper/search"
+    params = {
+        "query": query,
+        "limit": min(limit, 100),
+        # "fields": "paperId,title,abstract,year,authors,
+        # citationCount,url,publicationTypes,openAccessPdf",
+        "fields": "paperId,title,abstract,year,authors,citationCount,url",
+    }
+
+    # Add year parameter if provided
+    if year:
+        params["year"] = year
+
+    response = requests.get(endpoint, params=params, timeout=10)
+    data = response.json()
+    papers = data.get("data", [])
+
+    # Create a dictionary to store the papers
+    filtered_papers = {
+        paper["paperId"]: {
+            "Title": paper.get("title", "N/A"),
+            "Abstract": paper.get("abstract", "N/A"),
+            "Year": paper.get("year", "N/A"),
+            "Citation Count": paper.get("citationCount", "N/A"),
+            "URL": paper.get("url", "N/A"),
+            # "Publication Type": paper.get("publicationTypes", ["N/A"])[0]
+            # if paper.get("publicationTypes")
+            # else "N/A",
+            # "Open Access PDF": paper.get("openAccessPdf", {}).get("url", "N/A")
+            # if paper.get("openAccessPdf") is not None
+            # else "N/A",
+        }
+        for paper in papers
+        if paper.get("title") and paper.get("authors")
+    }
+
+    df = pd.DataFrame(filtered_papers)
+
+    # Format papers for state update
+    papers = [
+        f"Paper ID: {paper_id}\n"
+        f"Title: {paper_data['Title']}\n"
+        f"Abstract: {paper_data['Abstract']}\n"
+        f"Year: {paper_data['Year']}\n"
+        f"Citations: {paper_data['Citation Count']}\n"
+        f"URL: {paper_data['URL']}\n"
+        # f"Publication Type: {paper_data['Publication Type']}\n"
+        # f"Open Access PDF: {paper_data['Open Access PDF']}"
+        for paper_id, paper_data in filtered_papers.items()
+    ]
+
+    markdown_table = df.to_markdown(tablefmt="grid")
+    logging.info("Search results: %s", papers)
+
+    return Command(
+        update={
+            "papers": filtered_papers,  # Now sending the dictionary directly
+            "messages": [
+                ToolMessage(content=markdown_table, tool_call_id=tool_call_id)
+            ],
+        }
+    )

aiagents4pharma/talk2competitors/tools/s2/single_paper_rec.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python3
+
+"""
+This tool is used to return recommendations for a single paper.
+"""
+
+import logging
+from typing import Annotated, Any, Dict, Optional
+
+import pandas as pd
+import requests
+from langchain_core.messages import ToolMessage
+from langchain_core.tools import tool
+from langchain_core.tools.base import InjectedToolCallId
+from langgraph.types import Command
+from pydantic import BaseModel, Field
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class SinglePaperRecInput(BaseModel):
+    """Input schema for single paper recommendation tool."""
+
+    paper_id: str = Field(
+        description="Semantic Scholar Paper ID to get recommendations for (40-character string)"
+    )
+    limit: int = Field(
+        default=2,
+        description="Maximum number of recommendations to return",
+        ge=1,
+        le=500,
+    )
+    year: Optional[str] = Field(
+        default=None,
+        description="Year range in format: YYYY for specific year, "
+        "YYYY- for papers after year, -YYYY for papers before year, or YYYY:YYYY for range",
+    )
+    tool_call_id: Annotated[str, InjectedToolCallId]
+    model_config = {"arbitrary_types_allowed": True}
+
+
+@tool(args_schema=SinglePaperRecInput)
+def get_single_paper_recommendations(
+    paper_id: str,
+    tool_call_id: Annotated[str, InjectedToolCallId],
+    limit: int = 2,
+    year: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Get paper recommendations based on a single paper.
+
+    Args:
+        paper_id (str): The Semantic Scholar Paper ID to get recommendations for.
+        tool_call_id (Annotated[str, InjectedToolCallId]): The tool call ID.
+        limit (int, optional): The maximum number of recommendations to return. Defaults to 2.
+        year (str, optional): Year range for papers.
+        Supports formats like "2024-", "-2024", "2024:2025". Defaults to None.
+
+    Returns:
+        Dict[str, Any]: The recommendations and related information.
+    """
+    logger.info("Starting single paper recommendations search.")
+
+    endpoint = (
+        f"https://api.semanticscholar.org/recommendations/v1/papers/forpaper/{paper_id}"
+    )
+    params = {
+        "limit": min(limit, 500),  # Max 500 per API docs
+        "fields": "paperId,title,abstract,year,authors,citationCount,url",
+        "from": "all-cs",  # Using all-cs pool as specified in docs
+    }
+
+    # Add year parameter if provided
+    if year:
+        params["year"] = year
+
+    response = requests.get(endpoint, params=params, timeout=10)
+    data = response.json()
+    papers = data.get("data", [])
+    response = requests.get(endpoint, params=params, timeout=10)
+    # print(f"API Response Status: {response.status_code}")
+    logging.info(
+        "API Response Status for recommendations of paper %s: %s",
+        paper_id,
+        response.status_code,
+    )
+    # print(f"Request params: {params}")
+    logging.info("Request params: %s", params)
+
+    data = response.json()
+    recommendations = data.get("recommendedPapers", [])
+
+    # Extract paper ID and title from recommendations
+    filtered_papers = {
+        paper["paperId"]: {
+            "Title": paper.get("title", "N/A"),
+            "Abstract": paper.get("abstract", "N/A"),
+            "Year": paper.get("year", "N/A"),
+            "Citation Count": paper.get("citationCount", "N/A"),
+            "URL": paper.get("url", "N/A"),
+            # "Publication Type": paper.get("publicationTypes", ["N/A"])[0]
+            # if paper.get("publicationTypes")
+            # else "N/A",
+            # "Open Access PDF": paper.get("openAccessPdf", {}).get("url", "N/A")
+            # if paper.get("openAccessPdf") is not None
+            # else "N/A",
+        }
+        for paper in recommendations
+        if paper.get("title") and paper.get("authors")
+    }
+
+    # Create a DataFrame for pretty printing
+    df = pd.DataFrame(filtered_papers)
+
+    # Format papers for state update
+    papers = [
+        f"Paper ID: {paper_id}\n"
+        f"Title: {paper_data['Title']}\n"
+        f"Abstract: {paper_data['Abstract']}\n"
+        f"Year: {paper_data['Year']}\n"
+        f"Citations: {paper_data['Citation Count']}\n"
+        f"URL: {paper_data['URL']}\n"
+        # f"Publication Type: {paper_data['Publication Type']}\n"
+        # f"Open Access PDF: {paper_data['Open Access PDF']}"
+        for paper_id, paper_data in filtered_papers.items()
+    ]
+
+    # Convert DataFrame to markdown table
+    markdown_table = df.to_markdown(tablefmt="grid")
+    logging.info("Search results: %s", papers)
+
+    return Command(
+        update={
+            "papers": filtered_papers,  # Now sending the dictionary directly
+            "messages": [
+                ToolMessage(content=markdown_table, tool_call_id=tool_call_id)
+            ],
+        }
+    )

{aiagents4pharma-1.9.0.dist-info → aiagents4pharma-1.10.0.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.2
 Name: aiagents4pharma
-Version: 1.9.0
+Version: 1.10.0
 Summary: AI Agents for drug discovery, drug development, and other pharmaceutical R&D
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.10
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: copasi_basico==0.78
@@ -48,6 +48,9 @@ Requires-Dist: streamlit-feedback
 [![Talk2Cells](https://github.com/VirtualPatientEngine/AIAgents4Pharma/actions/workflows/tests_talk2cells.yml/badge.svg)](https://github.com/VirtualPatientEngine/AIAgents4Pharma/actions/workflows/tests_talk2cells.yml)
 [![Talk2KnowledgeGraphs](https://github.com/VirtualPatientEngine/AIAgents4Pharma/actions/workflows/tests_talk2knowledgegraphs.yml/badge.svg)](https://github.com/VirtualPatientEngine/AIAgents4Pharma/actions/workflows/tests_talk2knowledgegraphs.yml)
 [![Talk2Competitors](https://github.com/VirtualPatientEngine/AIAgents4Pharma/actions/workflows/tests_talk2competitors.yml/badge.svg)](https://github.com/VirtualPatientEngine/AIAgents4Pharma/actions/workflows/tests_talk2competitors.yml)
+![GitHub Release](https://img.shields.io/github/v/release/VirtualPatientEngine/AIAgents4Pharma)
+![Python Version from PEP 621 TOML](https://img.shields.io/python/required-version-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2FVirtualPatientEngine%2FAIAgents4Pharma%2Frefs%2Fheads%2Fmain%2Fpyproject.toml)
+
 
 <h1 align="center" style="border-bottom: none;">🤖 AIAgents4Pharma</h1>
 
@@ -56,9 +59,9 @@ Welcome to **AIAgents4Pharma** – an open-source project by [Team VPE](https://
 Our toolkit currently consists of three intelligent agents, each designed to simplify and enhance access to specialized data in biology:
 
 - **Talk2BioModels**: Engage directly with mathematical models in systems biology.
-- **Talk2Cells** *(Work in progress)*: Query and analyze sequencing data with ease.
-- **Talk2KnowledgeGraphs** *(Work in progress)*: Access and explore complex biological knowledge graphs for insightful data connections.
-- **Talk2Competitors** *(Coming soon)*: Get recommendations for articles related to your choice. Download, query, and write/retrieve them to your reference manager (currently supporting Zotero).
+- **Talk2Cells** _(Work in progress)_: Query and analyze sequencing data with ease.
+- **Talk2KnowledgeGraphs** _(Work in progress)_: Access and explore complex biological knowledge graphs for insightful data connections.
+- **Talk2Competitors** _(Coming soon)_: Get recommendations for articles related to your choice. Download, query, and write/retrieve them to your reference manager (currently supporting Zotero).
 
 ---
 
@@ -72,15 +75,15 @@ Our toolkit currently consists of three intelligent agents, each designed to sim
 - Adjust parameters within the model to simulate different conditions.
 - Query simulation results.
 
-### 2. Talk2Cells *(Work in Progress)*
+### 2. Talk2Cells _(Work in Progress)_
 
 **Talk2Cells** is being developed to provide direct access to and analysis of sequencing data, such as RNA-Seq or DNA-Seq, using natural language.
 
-### 3. Talk2KnowledgeGraphs *(Work in Progress)*
+### 3. Talk2KnowledgeGraphs _(Work in Progress)_
 
 **Talk2KnowledgeGraphs** is an agent designed to enable interaction with biological knowledge graphs (KGs). KGs integrate vast amounts of structured biological data into a format that highlights relationships between entities, such as proteins, genes, and diseases.
 
-### 4. Talk2KnowledgeGraphs *(Coming soon)*
+### 4. Talk2Competitors _(Coming soon)_
 
 ## Getting Started
 
@@ -91,48 +94,60 @@ Our toolkit currently consists of three intelligent agents, each designed to sim
 - Required libraries specified in `requirements.txt`
 
 ### Installation
+
 #### Option 1: PyPI
-   ```bash
-   pip install aiagents4pharma
-   ```
+
+```bash
+pip install aiagents4pharma
+```
 
 Check out the tutorials on each agent for detailed instrcutions.
 
 #### Option 2: git
+
 1. **Clone the repository:**
+
    ```bash
    git clone https://github.com/VirtualPatientEngine/AIAgents4Pharma
    cd AIAgents4Pharma
    ```
 
 2. **Install dependencies:**
+
    ```bash
    pip install .
    ```
 
 3. **Initialize OPENAI_API_KEY**
+
    ```bash
-   export OPENAI_API_KEY = ....
+   export OPENAI_API_KEY=....
    ```
 
 4. **[Optional] Set up login credentials**
+
    ```bash
    vi .streamlit/secrets.toml
    ```
+
    and enter
+
    ```
    password='XXX'
    ```
-   Please note that the passowrd will be same for all the users.
+
+   Please note that the passoword will be same for all the users.
 
 5. **[Optional] Initialize LANGSMITH_API_KEY**
+
    ```bash
    export LANGCHAIN_TRACING_V2=true
    export LANGCHAIN_API_KEY=<your-api-key>
    ```
-   Please note that this will create a new tracing project in your Langsmith 
-   account with the name `<user_name>@<uuid>`, where `user_name` is the name 
-   you provided in the previous step. If you skip the previous step, it will 
+
+   Please note that this will create a new tracing project in your Langsmith
+   account with the name `<user_name>@<uuid>`, where `user_name` is the name
+   you provided in the previous step. If you skip the previous step, it will
    default to `default`. <uuid> will be the 128 bit unique ID created for the
    session.
 
@@ -164,6 +179,7 @@ We welcome contributions to AIAgents4Pharma! Here’s how you can help:
 5. **Open a pull request**
 
 ### Current Needs
+
 - **Beta testers** for Talk2BioModels.
 - **Developers** with experience in natural language processing, bioinformatics, or knowledge graphs for contributions to AIAgents4Pharma.
 
@@ -174,19 +190,22 @@ Check out our [CONTRIBUTING.md](CONTRIBUTING.md) for more information.
 ## Roadmap
 
 ### Completed
+
 - **Talk2BioModels**: Initial release with core capabilities for interacting with systems biology models.
 
 ### Planned
+
 - **User Interface**: Interactive web UI for all agents.
 - **Talk2Cells**: Integration of sequencing data analysis tools.
 - **Talk2KnowledgeGraphs**: Interface for biological knowledge graph interaction.
-- **Talk2Competitors**
+- **Talk2Competitors**: Interface for exploring articles
 
-We’re excited to bring AIAgents4Pharma to the bioinformatics and pharmaceutical research community. Together, let’s make data-driven biological research more accessible and insightful. 
+We’re excited to bring AIAgents4Pharma to the bioinformatics and pharmaceutical research community. Together, let’s make data-driven biological research more accessible and insightful.
 
 **Get Started** with AIAgents4Pharma today and transform the way you interact with biological data.
 
 ---
 
 ## Feedback
+
 Questions/Bug reports/Feature requests/Comments/Suggestions? We welcome all. Please use the `Isssues` tab 😀

{aiagents4pharma-1.9.0.dist-info → aiagents4pharma-1.10.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-aiagents4pharma/__init__.py,sha256=X-Mpbf4sfjMvoxiTTl4qFgCxrWZgtVgRjnjX6gbUtCg,173
+aiagents4pharma/__init__.py,sha256=5muWWIg89VHPybfxonO_5xOMJPasKNsGdQRhozDaEmk,177
 aiagents4pharma/configs/__init__.py,sha256=hNkSrXw1Ix1HhkGn_aaidr2coBYySfM0Hm_pMeRcX7k,76
 aiagents4pharma/configs/config.yaml,sha256=8y8uG6Dzx4-9jyb6hZ8r4lOJz5gA_sQhCiSCgXL5l7k,65
 aiagents4pharma/configs/talk2biomodels/__init__.py,sha256=5ah__-8XyRblwT0U1ByRigNjt_GyCheu7zce4aM-eZE,68
@@ -34,7 +34,22 @@ aiagents4pharma/talk2cells/tools/__init__.py,sha256=38nK2a_lEFRjO3qD6Fo9a3983ZCY
 aiagents4pharma/talk2cells/tools/scp_agent/__init__.py,sha256=s7g0lyH1lMD9pcWHLPtwRJRvzmTh2II7DrxyLulpjmQ,163
 aiagents4pharma/talk2cells/tools/scp_agent/display_studies.py,sha256=6q59gh_NQaiOU2rn55A3sIIFKlXi4SK3iKgySvUDrtQ,600
 aiagents4pharma/talk2cells/tools/scp_agent/search_studies.py,sha256=MLe-twtFnOu-P8P9diYq7jvHBHbWFRRCZLcfpUzqPMg,2806
-aiagents4pharma/talk2competitors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aiagents4pharma/talk2competitors/__init__.py,sha256=haaikzND3c0Euqq86ndA4fl9q42aOop5rYG_8Zh1D-o,119
+aiagents4pharma/talk2competitors/agents/__init__.py,sha256=ykszlVGxz3egLHZAttlNoTPxIrnQJZYva_ssR8fwIFk,117
+aiagents4pharma/talk2competitors/agents/main_agent.py,sha256=UoHCpZd-HoeG0B6_gAF1cEP2OqMvrTuGe7MZDwL_u1U,3878
+aiagents4pharma/talk2competitors/agents/s2_agent.py,sha256=eTrhc4ZPvWOUWMHNYxK0WltsZedZUnAWNu-TeUa-ruk,2501
+aiagents4pharma/talk2competitors/config/__init__.py,sha256=HyM6paOpKZ5_tZnyVheSAFmxjT6Mb3PxvWKfP0rz-dE,113
+aiagents4pharma/talk2competitors/config/config.py,sha256=jd4ltMBJyTztm9wT7j3ujOyYxL2SXRgxQJ4OZUBmCG4,5387
+aiagents4pharma/talk2competitors/state/__init__.py,sha256=DzFjV3hZNes_pL4bDW2_8RsyK9BJcj6ejfBzU0KWn1k,106
+aiagents4pharma/talk2competitors/state/state_talk2competitors.py,sha256=GUl1ZfM77XsjIEu-3xy4dtvaiMTA1pXf6i1ozVcX5Gg,993
+aiagents4pharma/talk2competitors/tests/__init__.py,sha256=U3PsTiUZaUBD1IZanFGkDIOdFieDVJtGKQ5-woYUo8c,45
+aiagents4pharma/talk2competitors/tests/test_langgraph.py,sha256=sEROK1aU3wFqJhZohONVI6Pr7t1d3PSqs-4erVIyiJw,9283
+aiagents4pharma/talk2competitors/tools/__init__.py,sha256=YudBDRwaEzDnAcpxGZvEOfyh5-6xd51CTvTKTkywgXw,68
+aiagents4pharma/talk2competitors/tools/s2/__init__.py,sha256=9RQH3efTj6qkXk0ICKSc7Mzpkitt4gRGsQ1pGPrrREU,181
+aiagents4pharma/talk2competitors/tools/s2/display_results.py,sha256=B8JJGohi1Eyx8C3MhO_SiyQP3R6hPyUKJOAzcHmq3FU,584
+aiagents4pharma/talk2competitors/tools/s2/multi_paper_rec.py,sha256=FYLt47DAk6WOKfEk1Gj9zVvJGNyxA283PCp8IKW9U5M,4262
+aiagents4pharma/talk2competitors/tools/s2/search.py,sha256=pppjrQv5-8ep4fnqgTSBNgnbSnQsVIcNrRrH0p2TP1o,4025
+aiagents4pharma/talk2competitors/tools/s2/single_paper_rec.py,sha256=dAfUQxI7T5eu0eDxK8VAl7-JH0Wnw24CVkOQqwj-hXc,4810
 aiagents4pharma/talk2knowledgegraphs/__init__.py,sha256=SW7Ys2A4eXyFtizNPdSw91SHOPVUBGBsrCQ7TqwSUL0,91
 aiagents4pharma/talk2knowledgegraphs/datasets/__init__.py,sha256=L3gPuHskSegmtXskVrLIYr7FXe_ibKgJ2GGr1_Wok6k,173
 aiagents4pharma/talk2knowledgegraphs/datasets/biobridge_primekg.py,sha256=QlzDXmXREoa9MA6-GwzqRjdzndQeGBAF11Td6NFk_9Y,23426
@@ -55,8 +70,8 @@ aiagents4pharma/talk2knowledgegraphs/utils/embeddings/__init__.py,sha256=xRb0x7S
 aiagents4pharma/talk2knowledgegraphs/utils/embeddings/embeddings.py,sha256=1nGznrAj-xT0xuSMBGz2dOujJ7M_IwSR84njxtxsy9A,2523
 aiagents4pharma/talk2knowledgegraphs/utils/embeddings/huggingface.py,sha256=2vi_elf6EgzfagFAO5QnL3a_aXZyN7B1EBziu44MTfM,3806
 aiagents4pharma/talk2knowledgegraphs/utils/embeddings/sentence_transformer.py,sha256=36iKlisOpMtGR5xfTAlSHXWvPqVC_Jbezod8kbBBMVg,2136
-aiagents4pharma-1.9.0.dist-info/LICENSE,sha256=IcIbyB1Hyk5ZDah03VNQvJkbNk2hkBCDqQ8qtnCvB4Q,1077
-aiagents4pharma-1.9.0.dist-info/METADATA,sha256=c8KtNUIWjkl_hwW4ebu9SlAXiG7BWPX5CoMeC2T4Jb8,7988
-aiagents4pharma-1.9.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-aiagents4pharma-1.9.0.dist-info/top_level.txt,sha256=-AH8rMmrSnJtq7HaAObS78UU-cTCwvX660dSxeM7a0A,16
-aiagents4pharma-1.9.0.dist-info/RECORD,,
+aiagents4pharma-1.10.0.dist-info/LICENSE,sha256=IcIbyB1Hyk5ZDah03VNQvJkbNk2hkBCDqQ8qtnCvB4Q,1077
+aiagents4pharma-1.10.0.dist-info/METADATA,sha256=a5XUji4VHk7HcE5GC7txe7v2sNUbgH4ijSHpxoNh74E,8340
+aiagents4pharma-1.10.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+aiagents4pharma-1.10.0.dist-info/top_level.txt,sha256=-AH8rMmrSnJtq7HaAObS78UU-cTCwvX660dSxeM7a0A,16
+aiagents4pharma-1.10.0.dist-info/RECORD,,