Upload 9 files

.gitignore

@@ -0,0 +1,11 @@
+.env
+__pycache__
+build
+dist
+flet_ui.spec
+web_ui/node_modules
+web_ui/.nuxt
+index
+.venv
+upload space.py
+flet_app.spec

agent.py

@@ -0,0 +1,64 @@
+from langgraph.prebuilt import create_react_agent
+from langgraph.checkpoint.memory import MemorySaver
+from typing import Any, Iterator
+from tools import search, get_commentaries, read_text
+from llm_providers import LLMProvider
+
+SYSTEM_PROMPT = """
+    אתה מסייע תורני רב עוצמה, משול לתלמיד חכם הבקיא בכל רזי התורה. התפקיד שלך הוא לסייע למשתמשים בלימוד התורה בצורה מעמיקה וחכמה. עליך להבין את כוונת השואל, לנתח את השאלה לעומק, ולבצע חיפוש מתוחכם בטקסטים יהודיים ותורניים.
+
+    עליך לענות תשובות אך ורק על פי מקורות שמצאת בחיפוש ועיון מעמיק, ולא על פי ידע קודם.
+
+    כאשר אתה מקבל שאלה מהמשתמש, עליך לנסות להבין את כוונתו, את ההקשר ההיסטורי וההלכתי, ואת המקורות הרלוונטיים. עליך ליצור שאילתת חיפוש מתאימה באמצעות הכלי search, תוך שימוש בשפה תורנית מדויקת. עבור תנ"ך השתמש בשפה מקראית, לחיפוש בתלמוד חפש בארמית, וכן הלאה. תוכל לצמצם את החיפוש לפי נושאים, תקופות, מחברים, ואף לפי שם הספר או הקטע הדרוש.
+
+    אם לא מצאת תוצאות רלוונטיות, אל תתייאש. נסה שוב ושוב, תוך שימוש בשאילתות מגוונות, מילים נרדפות, הטיות שונות של מילות המפתח, וצמצום או הרחבת היקף החיפוש. זכור, תלמיד חכם אמיתי אינו מוותר עד שהוא מוצא את האמת.
+
+    כאשר אתה מוצא מקורות רלוונטיים, עליך לקרוא אותם בעיון ובקפידה באמצעות הכלי get_text. אם יש צורך, תוכל להיעזר בכלי get_commentaries כדי לקבל רשימה של פרשנים על טקסט מסוים.
+
+    עליך לשאוף למצוא את המקורות הקדומים והמוסמכים ביותר לכל פרט בשאלה. לדוגמה, אם מצאת הלכה מסוימת בספר שיצא לאחרונה, נסה למצוא את מקורה בשולחן ערוך, ואז בגמרא, ואף במשנה או במקרא. השתמש בספר "באר הגולה" על שולחן ערוך כדי למצוא את המקורות בגמרא.
+
+    לאחר שאספת את כל המידע הרלוונטי, עליך לעבד אותו, לקשר בין מקורות שונים, ולנסח תשובה מפורטת, בהירה ומדויקת. עליך להתייחס לכל היבטי השאלה, תוך ציון המקורות לכל פרט בתשובה.
+
+    זכור, אתה משול לתלמיד חכם, ועל כן עליך להפגין בקיאות, חריפות, עמקות ודייקנות בכל תשובותיך.
+    """
+
+class Agent:
+    def __init__(self,index_path: str):
+        self.llm_provider = LLMProvider() 
+        self.llm = self.llm_provider.get_provider(self.llm_provider.get_available_providers()[0])
+        self.memory_saver = MemorySaver()
+        self.tools = [read_text, get_commentaries, search]
+        self.graph = create_react_agent(
+            model=self.llm,
+            checkpointer=self.memory_saver,
+            tools=self.tools,
+            state_modifier=SYSTEM_PROMPT
+        )
+        self.current_thread_id = 1
+        
+    def set_llm(self, provider_name: str):
+        self.llm = self.llm_provider.get_provider(provider_name)
+        self.graph = create_react_agent(
+            model=self.llm,
+            checkpointer=self.memory_saver,
+            tools=self.tools,
+            state_modifier=SYSTEM_PROMPT
+        )
+        
+    def get_llm(self) -> str:
+        return self.llm
+
+    def clear_chat(self):
+        self.current_thread_id += 1
+        
+    def chat(self, message) -> dict[str, Any]:
+        """Chat with the agent and stream responses including tool calls and their results."""
+        config = {"configurable": {"thread_id": self.current_thread_id}}
+        inputs = {"messages": [("user", message)]}
+        return self.graph.stream(inputs,stream_mode="values", config=config)
+
+        
+    def get_chat_history(self, id = None) -> Iterator[dict[str, Any]]:
+        if id is None:
+            id = self.current_thread_id
+        return self.memory_saver.get(thread_id=str(self.current_thread_id))

app.py

@@ -0,0 +1,318 @@
+import streamlit as st
+import os
+from typing import Optional, List
+from dotenv import load_dotenv
+import gdown
+import llm_providers
+import tantivy_search
+import agent
+import json
+import zipfile
+
+
+INDEX_PATH = "./index"
+
+# Load environment variables
+load_dotenv()
+
+class SearchAgentUI:
+    index_path = INDEX_PATH
+    gdrive_index_id = os.getenv("GDRIVE_INDEX_ID", "1lpbBCPimwcNfC0VZOlQueA4SHNGIp5_t")
+
+   
+    @st.cache_resource
+    def get_agent(_self): 
+        index_path = INDEX_PATH
+        return agent.Agent(index_path)    
+
+    def download_index_from_gdrive(self) -> bool:
+        try:
+            zip_path = "index.zip"
+            url = f"https://drive.google.com/uc?id={self.gdrive_index_id}"
+            gdown.download(url, zip_path, quiet=False)  
+            with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+                zip_ref.extractall(".")
+            os.remove(zip_path) 
+            return True
+        
+        except Exception as e:
+            st.error(f"Failed to download index: {str(e)}")
+            return False
+        
+        
+    @st.cache_resource
+    def initialize_system(_self,api_keys:dict[str,str]) -> tuple[bool, str, List[str]]:
+        
+        try:
+            # download index
+            if not os.path.exists(_self.index_path):
+                st.warning("Index folder not found. Attempting to download from Google Drive...")
+                if not _self.download_index_from_gdrive():
+                    return False, "שגיאה: לא ניתן להוריד את האינדקס", []
+                st.success("Index downloaded successfully!")
+            _self.llm_providers = llm_providers.LLMProvider(api_keys)   
+            available_providers = _self.llm_providers.get_available_providers()
+            if not available_providers:
+                return False, "שגיאה: לא נמצאו ספקי AI זמינים. אנא הזן מפתח API אחד לפחות.", []           
+            return True, "המערכת מוכנה לחי শবפש", available_providers
+         
+        except Exception as ex:
+            return False, f"שגיאה באתחול המערכת: {str(ex)}", []
+
+    def update_messages(self, messages):
+        st.session_state.messages = messages
+        
+    def main(self):
+        st.set_page_config(
+            page_title="איתוריא",
+            layout="wide",
+            initial_sidebar_state="expanded"
+        )
+        
+        
+        # Enhanced styling with better visual hierarchy and modern design
+        st.markdown("""
+        <style>
+            /* Global RTL Support */
+            .stApp {
+                direction: rtl;
+                background-color: #f8f9fa;
+            }
+            
+            /* Input Fields RTL */
+            .stTextInput > div > div > input,
+            .stSelectbox > div > div > div,
+            .stNumberInput > div > div > input {
+                direction: rtl;
+                border-radius: 8px !important;
+                border: 2px solid #e2e8f0 !important;
+                padding: 0.75rem !important;
+                transition: all 0.3s ease;
+            }
+            
+            .stTextInput > div > div > input:focus,
+            .stSelectbox > div > div > div:focus {
+                border-color: #4299e1 !important;
+                box-shadow: 0 0 0 1px #4299e1 !important;
+            }
+            
+            /* Message Containers */
+            .chat-container {
+                background: white;
+                border-radius: 12px;
+                padding: 1.5rem;
+                margin: 1rem 0;
+                box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+            }
+            
+            /* Tool Calls Styling */
+            .tool-call {
+                background: #f0f7ff;
+                border-radius: 8px;
+                padding: 1rem;
+                margin: 0.5rem 0;
+                border-right: 4px solid #3182ce;
+            }
+            
+            /* Search Results */
+            .search-step {
+                background: white;
+                border-radius: 10px;
+                padding: 1.25rem;
+                margin: 1rem 0;
+                box-shadow: 0 2px 4px rgba(0,0,0,0.05);
+                border: 1px solid #e2e8f0;
+            }
+            
+            .document-group {
+                background: #f7fafc;
+                border-radius: 8px;
+                padding: 1rem;
+                margin: 0.75rem 0;
+                border: 1px solid #e2e8f0;
+            }
+            
+            .document-item {
+                background: white;
+                border-radius: 6px;
+                padding: 1rem;
+                margin: 0.5rem 0;
+                border: 1px solid #edf2f7;
+            }
+            
+            /* Sidebar Styling */
+            [data-testid="stSidebar"] {
+                direction: rtl;
+                background-color: #f8fafc;
+                padding: 2rem 1rem;
+            }
+            
+            .sidebar-content {
+                padding: 1rem;
+            }
+            
+            /* Chat Messages */
+            .stChatMessage {
+                direction: rtl;
+                background: white !important;
+                border-radius: 12px !important;
+                padding: 1rem !important;
+                margin: 0.75rem 0 !important;
+                box-shadow: 0 2px 4px rgba(0,0,0,0.05) !important;
+            }
+            
+            /* Buttons */
+            .stButton > button {
+                border-radius: 8px !important;
+                padding: 0.5rem 1.5rem !important;
+                background-color: #3182ce !important;
+                color: white !important;
+                border: none !important;
+                transition: all 0.3s ease !important;
+            }
+            
+            .stButton > button:hover {
+                background-color: #2c5282 !important;
+                transform: translateY(-1px);
+            }
+            
+            /* Code Blocks */
+            .stCodeBlock {
+                direction: ltr;
+                text-align: left;
+                border-radius: 8px !important;
+                background: #2d3748 !important;
+            }
+            
+            /* Links */
+            a {
+                color: #3182ce;
+                text-decoration: none;
+                transition: color 0.2s ease;
+            }
+            
+            a:hover {
+                color: #2c5282;
+                text-decoration: underline;
+            }
+            
+            /* Error Messages */
+            .stAlert {
+                border-radius: 8px !important;
+                border: none !important;
+            }
+        </style>
+        """, unsafe_allow_html=True)
+        
+        # Initialize session state for message deduplication
+        if "messages" not in st.session_state:
+            st.session_state.messages = []
+
+        st.session_state.api_keys = {
+            'google': "",
+            'openai': "",
+            'anthropic': ""
+        }
+
+        # Sidebar settings
+        with st.sidebar:
+            st.title("הגדרות")
+            
+            st.subheader("הגדרת מפתחות API")
+            
+            # API Key inputs with improved styling
+            for provider, label in [
+                ('google', 'Google API Key'),
+                ('openai', 'OpenAI API Key'),
+                ('anthropic', 'Anthropic API Key')
+            ]:
+                key = st.text_input(
+                    label,
+                    value=st.session_state.api_keys[provider],
+                    type="password",
+                    key=f"{provider}_key",
+                    help=f"הזן את מפתח ה-API של {label}"
+                )
+                st.session_state.api_keys[provider] = key
+                
+                # Provider-specific links
+                links = {
+                    'google': 'https://aistudio.google.com/app/apikey',
+                    'openai': 'https://platform.openai.com/account/api-keys',
+                    'anthropic': 'https://console.anthropic.com/'
+                }
+                st.html(f'<small> ניתן להשיג מפתח <a href="{links[provider]}">כאן</a> </small>')
+
+            st.markdown("---")
+
+        # Initialize system
+        success, status_msg, available_providers = self.initialize_system(st.session_state.api_keys)
+
+        if not success:
+            st.error(status_msg)
+            return
+        
+        agent = self.get_agent()
+
+        # Provider selection in sidebar
+        with st.sidebar:
+          
+                if 'provider' not in st.session_state or st.session_state.provider not in available_providers:
+                    st.session_state.provider = available_providers[0] 
+                
+                provider = st.selectbox(
+                    "ספק בינה מלאכותית",
+                    options=available_providers,
+                    key='provider',
+                    help="בחר את מודל הAI לשימוש (רק מודלים עם מפתח API זמין יוצגו)"
+                )
+                if agent:
+                    agent.set_llm(provider)
+
+
+
+        # Main chat interface
+        
+        query = st.chat_input("הזן שאלה", key="chat_input")        
+        if query:
+           stream = agent.chat(query)
+           for chunk in stream:
+                st.session_state.messages = chunk["messages"]
+        if st.button("צ'אט חדש"):
+            st.session_state.messages = []
+            agent.clear_chat()
+           
+        for message in st.session_state.messages: 
+                if message.type == "tool":                            
+                                    if message.name == "search":
+                                        results =json.loads(message.content) if message.content else []
+                                        with st.expander(f"🔍 תוצאות חיפוש: {len(results)}"):
+                                            for result in results:
+                                                st.write(result['reference'])
+                                                st.info(result['text'])
+                                    elif message.name == "get_text":
+                                        st.expander(f"📝 טקסט: {message.content}")
+                                    
+                elif message.type == "ai" :
+                    if message.content != "":
+                      
+                        with st.chat_message(message.type):
+                            if isinstance(message.content, list):
+                                for item in message.content:
+                                    if ('text' in item):
+                                        st.write(item['text'])                                
+
+                            else:
+                                st.write(message.content)
+                                
+                    for tool_call in message.tool_calls:
+                        with st.expander(f"🛠️ שימוש בכלי: {tool_call["name"]}"):
+                            st.json(tool_call["args"])                                
+                else: 
+                    with st.chat_message(message.type):
+                        st.write(message.content)  
+           
+
+if __name__ == "__main__":
+    app = SearchAgentUI()
+    app.main()

chat_gemini.py

@@ -0,0 +1,264 @@
+import json
+from random import choices
+import string
+from langchain.tools import BaseTool
+import requests
+from dotenv import load_dotenv
+from dataclasses import dataclass
+from langchain_core.language_models.chat_models import BaseChatModel
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    List,
+    Literal,
+    Mapping,
+    Optional,
+    Sequence,
+    Type,
+    Union,
+    cast,
+)
+from langchain_core.callbacks import (
+    CallbackManagerForLLMRun,
+)
+from langchain_core.callbacks.manager import AsyncCallbackManagerForLLMRun
+from langchain_core.exceptions import OutputParserException
+from langchain_core.language_models import LanguageModelInput
+from langchain_core.language_models.chat_models import BaseChatModel, LangSmithParams
+from langchain_core.messages import (
+    AIMessage,
+    BaseMessage,
+    HumanMessage,
+    ToolMessage,
+    SystemMessage,
+)
+from langchain_core.outputs import ChatGeneration, ChatResult
+from langchain_core.runnables import Runnable
+from langchain_core.tools import BaseTool
+
+
+class ChatGemini(BaseChatModel): 
+     
+    @property
+    def _llm_type(self) -> str:
+        """Get the type of language model used by this chat model."""
+        return "gemini"
+
+    api_key :str
+    base_url:str =  "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash-exp:generateContent"
+    model_kwargs: Any = {}
+    
+    def _generate(
+        self,
+        messages: list[BaseMessage],
+        stop: Optional[list[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,     
+        **kwargs: Any,
+    ) -> ChatResult:
+        """Generate a chat response using the Gemini API.
+        
+        This method handles both regular text responses and function calls.
+        For function calls, it returns a ToolMessage with structured function call data
+        that can be processed by Langchain's agent executor.
+        
+        Function calls are returned with:
+        - tool_name: The name of the function to call
+        - tool_call_id: A unique identifier for the function call (name is used as Gemini doesn't provide one)
+        - content: The function arguments as a JSON string
+        - additional_kwargs: Contains the full function call details
+        
+        Args:
+            messages: List of input messages
+            stop: Optional list of stop sequences
+            run_manager: Optional callback manager
+            **kwargs: Additional arguments passed to the Gemini API
+            
+        Returns:
+            ChatResult containing either an AIMessage for text responses
+            or a ToolMessage for function calls
+        """
+        # Convert messages to Gemini format
+        gemini_messages = []
+        system_message = None
+        for msg in messages:
+            # Handle both dict and LangChain message objects
+            if isinstance(msg, BaseMessage):
+                if isinstance(msg, SystemMessage):
+                    system_message = msg.content
+                    kwargs["system_instruction"]= {"parts":[{"text": system_message}]}
+                    continue
+                if isinstance(msg, HumanMessage):
+                    role = "user"
+                    content = msg.content
+                elif isinstance(msg, AIMessage):
+                    role = "model"
+                    content = msg.content
+                elif isinstance(msg, ToolMessage):
+                    # Handle tool messages by adding them as function outputs
+                    gemini_messages.append(
+                        {
+                        "role": "model",
+                        "parts": [{
+                        "functionResponse": {
+                            "name": msg.name,
+                            "response": {"name": msg.name, "content": msg.content},                         
+                        }}]}
+                   )
+                    continue
+            else:
+                role = "user" if msg["role"] == "human" else "model"
+                content = msg["content"]
+                
+            message_part = {
+                "role": role,
+                "parts":[{"functionCall": { "name": msg.tool_calls[0]["name"], "args": msg.tool_calls[0]["args"]}}] if isinstance(msg, AIMessage) and msg.tool_calls else [{"text": content}]
+            }
+            gemini_messages.append(message_part)
+            
+       
+        
+        # Prepare the request
+        headers = {
+            "Content-Type": "application/json"
+        }
+        
+        params = {
+            "key": self.api_key
+        }
+        
+        data = {
+            "contents": gemini_messages,
+            "generationConfig": {
+                "temperature": 0.7,
+                "topP": 0.8,
+                "topK": 40,
+                "maxOutputTokens": 2048,
+            },
+            **kwargs
+        }
+
+       
+        try:
+            response = requests.post(
+                self.base_url,
+                headers=headers,
+                params=params,
+                json=data,
+                verify='C:\\ProgramData\\NetFree\\CA\\netfree-ca-bundle-curl.crt'
+            )
+            response.raise_for_status()
+            
+            result = response.json()
+            if "candidates" in result and len(result["candidates"]) > 0 and "parts" in result["candidates"][0]["content"]:
+                parts = result["candidates"][0]["content"]["parts"]
+                tool_calls = []
+                content = ""
+                for part in  parts: 
+                    if "text" in part:
+                        content += part["text"]                                      
+                    if "functionCall" in part:                       
+                        function_call = part["functionCall"]
+                        tool_calls.append( {
+                                    "name": function_call["name"],
+                                    "id": function_call["name"]+random_string(5), # Gemini doesn't provide a unique id,}
+                                    "args": function_call["args"],
+                                    "type": "tool_call",})  
+                    # Create a proper ToolMessage with structured function call data
+                return ChatResult(generations=[
+                        ChatGeneration(
+                            message=AIMessage(
+                                content=content,
+                                tool_calls=tool_calls,                                
+                            ) if len(tool_calls) > 0 else AIMessage(content=content)
+                        )
+                    ])
+                
+        
+            else:
+                raise Exception("No response generated")
+                
+        except Exception as e:
+            raise Exception(f"Error calling Gemini API: {str(e)}")
+
+   
+    def bind_tools(
+        self,
+        tools: Sequence[Union[Dict[str, Any], Type, Callable, BaseTool]],
+        *,
+        tool_choice: Optional[Union[dict, str, Literal["auto", "any"], bool]] = None,
+        **kwargs: Any,
+    ) -> Runnable[LanguageModelInput, BaseMessage]:
+        """Bind tool-like objects to this chat model.
+
+
+        Args:
+            tools: A list of tool definitions to bind to this chat model.
+                Supports any tool definition handled by
+                :meth:`langchain_core.utils.function_calling.convert_to_openai_tool`.
+            tool_choice: If provided, which tool for model to call. **This parameter
+                is currently ignored as it is not supported by Ollama.**
+            kwargs: Any additional parameters are passed directly to
+                ``self.bind(**kwargs)``.
+        """
+        
+        formatted_tools = {"function_declarations": [convert_to_gemini_tool(tool) for tool in tools]}
+        return super().bind(tools=formatted_tools, **kwargs)
+    
+def convert_to_gemini_tool(
+    tool: Union[BaseTool],
+    *,
+    strict: Optional[bool] = None,
+) -> dict[str, Any]:
+    """Convert a tool-like object to an Gemini tool schema.
+
+    Gemini tool schema reference:
+   https://ai.google.dev/gemini-api/docs/function-calling#function_calling_mode
+
+    Args:
+        tool:           
+            BaseTool. 
+        strict:
+            If True, model output is guaranteed to exactly match the JSON Schema
+            provided in the function definition. If None, ``strict`` argument will not
+            be included in tool definition.
+
+    Returns:
+        A dict version of the passed in tool which is compatible with the
+        Gemini tool-calling API.
+    """
+    if isinstance(tool, BaseTool):
+        # Extract the tool's schema
+        schema = tool.args_schema.schema() if tool.args_schema else {"type": "object", "properties": {}}
+        
+        #convert to gemini schema 
+        raw_properties = schema.get("properties", {})
+        properties = {}
+        for key, value in raw_properties.items():
+            properties[key] = {
+                "type": value.get("type", "string"),
+                "description": value.get("title", ""),
+            }
+        
+        
+        # Build the function definition
+        function_def = {
+            "name": tool.name,
+            "description": tool.description,
+            "parameters": {
+                "type": "object",
+                "properties": properties,
+                "required": schema.get("required", [])
+            }
+        }
+        
+        if strict is not None:
+            function_def["strict"] = strict
+            
+        return function_def
+    else:
+        raise ValueError(f"Unsupported tool type: {type(tool)}")
+
+def random_string(length: int) -> str:
+    return ''.join(choices(string.ascii_letters + string.digits, k=length))
+    

llm_providers.py

@@ -0,0 +1,77 @@
+from langchain_anthropic import ChatAnthropic
+from langchain_openai import ChatOpenAI
+from langchain_ollama import ChatOllama
+from langchain_core.language_models.base import BaseLanguageModel
+from langchain_core.messages import BaseMessage, HumanMessage, AIMessage
+from typing import Optional, Dict, List, Any, Sequence
+from langchain.tools import BaseTool
+import os
+import requests
+import json
+from dotenv import load_dotenv
+from dataclasses import dataclass
+import ollama
+import copy
+from chat_gemini import ChatGemini
+
+
+load_dotenv()
+
+
+
+class LLMProvider:
+    
+    def __init__(self, api_keys: Optional[Dict[str, str]] = None):
+        if api_keys:
+            self.api_keys = api_keys
+        self.providers: Dict[str, Any] = {}
+        self._setup_providers()
+
+    def _get_ollama_models(self) -> List[str]:
+        """Get list of available Ollama models using the ollama package"""
+        try:
+            models = ollama.list()
+            return [model.model for model in models['models']]
+        except Exception:
+            return []
+
+    def _setup_providers(self):
+        os.environ['REQUESTS_CA_BUNDLE'] = 'C:\\ProgramData\\NetFree\\CA\\netfree-ca-bundle-curl.crt'
+        
+        # Google Gemini
+        if google_key := os.getenv('GOOGLE_API_KEY') or self.api_keys.get('google'): 
+            self.providers['Gemini'] = ChatGemini(api_key=google_key)
+        
+        # Anthropicsel
+        if anthropic_key := os.getenv('ANTHROPIC_API_KEY')  or self.api_keys.get('anthropic'):
+            self.providers['Claude'] = ChatAnthropic(
+                api_key=anthropic_key,
+                model_name="claude-3-5-sonnet-20241022",
+            )
+
+        # OpenAI
+        if openai_key := os.getenv('OPENAI_API_KEY') or self.api_keys.get('openai'):
+            self.providers['ChatGPT'] = ChatOpenAI(
+                api_key=openai_key,
+                model_name="gpt-4o-2024-11-20",
+                max_completion_tokens=4096,
+              
+            )
+
+        # Ollama (local)
+        try:
+            # Get available Ollama models using the ollama package
+            ollama_models = self._get_ollama_models()
+            for model in ollama_models:
+                self.providers[f'Ollama-{model}'] = ChatOllama(model=model)
+        except Exception:
+            pass  # Ollama not available
+
+    def get_available_providers(self) -> list[str]:        
+        """Return list of available provider names"""
+  
+        return list(self.providers.keys())
+
+    def get_provider(self, name: str) -> Optional[Any]:
+        """Get LLM provider by name"""
+        return self.providers.get(name)

requirements.txt

@@ -0,0 +1,14 @@
+langchain
+langgraph
+python-dotenv
+flet
+langchain-community
+langchain-core
+langchain-openai
+langchain-anthropic
+langchain-ollama
+ollama
+requests
+tantivy
+gdown
+pydantic

sefaria.py

@@ -0,0 +1,83 @@
+import requests, json
+
+SEFARIA_API_BASE_URL = "http://localhost:8000"
+
+def _get_request_json_data(endpoint, ref=None, param=None):
+    """
+    Helper function to make GET requests to the Sefaria API and parse the JSON response.
+    """
+    url = f"{SEFARIA_API_BASE_URL}/{endpoint}"
+
+    if ref:
+        url += f"{ref}"
+
+    if param:
+        url += f"?{param}"
+
+    try:
+        response = requests.get(url)
+        response.raise_for_status()  # Raise an exception for bad status codes
+        data = response.json()
+        return data
+    except requests.exceptions.RequestException as e:
+        print(f"Error during API request: {e}")
+        return None
+    
+
+def get_text(reference: str) -> str:
+    """
+    Retrieves the text for a given reference.
+    """
+    return str(_get_hebrew_text(reference))
+
+
+def get_weekly_parasha():
+    """
+    Retrieves the weekly Parasha data using the Calendars API.
+    """
+    data = _get_request_json_data("api/calendars")
+
+    if data:
+        calendar_items = data.get('calendar_items', [])
+        for item in calendar_items:
+            if item.get('title', {}).get('en') == 'Parashat Hashavua':
+                parasha_ref = item.get('ref')
+                parasha_description = item.get('description', {}).get('he')
+                parasha_name_he = item.get('displayValue', {}).get('he')
+                return {
+                    "ref": parasha_ref,
+                    "description": parasha_description,
+                    "name_he": parasha_name_he
+                }
+    
+    print("Could not retrieve Parasha data.")
+    return None
+
+
+def _get_hebrew_text(parasha_ref):
+    """
+    Retrieves the Hebrew text and version title for the given verse.
+    """
+    data = _get_request_json_data("api/v3/texts/", parasha_ref)
+
+    if data and "versions" in data and len(data['versions']) > 0:
+        he_pasuk = data['versions'][0]['text']
+        return  he_pasuk
+    else:
+        print(f"Could not retrieve Hebrew text for {parasha_ref}")
+        return None
+
+
+def get_commentaries(parasha_ref)-> list[str]:
+    """
+    Retrieves and filters commentaries on the given verse.
+    """
+    data = _get_request_json_data("api/related/", parasha_ref)
+
+    commentaries = []
+    if data and "links" in data:
+        for linked_text in data["links"]:
+            if linked_text.get('type') == 'commentary':
+                commentaries.append(linked_text.get('sourceHeRef'))
+
+    return commentaries

tantivy_search.py

@@ -0,0 +1,165 @@
+from typing import List, Dict, Any, Optional
+from tantivy import Index
+import logging
+import os
+import re
+
+
+class TantivySearch:
+    def __init__(self, index_path: str):
+        """Initialize the Tantivy search agent with the index path"""
+        self.index_path = index_path
+        self.logger = logging.getLogger(__name__)
+        try:
+            self.index = Index.open(index_path)
+            self.logger.info(f"Successfully opened Tantivy index at {index_path}")
+        except Exception as e:
+            self.logger.error(f"Failed to open Tantivy index: {e}")
+            raise
+
+    def get_query_instructions(self) -> str:
+        """Return instructions for the LLM on how to parse and construct Tantivy queries"""
+        return """
+Instructions for generating a query:
+
+1. Boolean Operators:
+
+   - AND: term1 AND term2 (both required)
+   - OR: term1 OR term2 (either term)
+   - Multiple words default to OR operation (cloud network = cloud OR network)
+   - AND takes precedence over OR
+   - Example: Shabath AND (walk OR go)
+
+2. Field-specific Terms:
+   - Field-specific terms: field:term
+   - Example: text:אדם AND reference:בראשית
+   - available fields: text, reference, topics
+   - text contains the text of the document
+   - reference contains the citation of the document, e.g. בראשית, פרק א
+   - topics contains the topics of the document. available topics includes: תנך, הלכה, מדרש, etc.
+
+3. Required/Excluded Terms:
+   - Required (+): +term (must contain)
+   - Excluded (-): -term (must not contain)
+   - Example: +security cloud -deprecated
+   - Equivalent to: security AND cloud AND NOT deprecated
+
+4. Phrase Search:
+   - Use quotes: "exact phrase"
+   - Both single/double quotes work
+   - Escape quotes with \\"
+   - Slop operator: "term1 term2"~N 
+   - Example: "cloud security"~2 
+   - the above will find "cloud framework and security "
+   - Prefix matching: "start of phrase"*
+
+5. Wildcards:
+   - ? for single character
+   - * for any number of characters
+   - Example: sec?rity cloud*
+
+6. Special Features:
+   - All docs: * 
+   - Boost terms: term^2.0 (positive numbers only)
+   - Example: security^2.0 cloud
+   - the above will boost security by 2.0
+   
+Query Examples:
+1. Basic: +שבת +חולה +אסור
+2. Field-specific: text:סיני AND topics:תנך
+3. Phrase with slop: "security framework"~2
+4. Complex: +reference:בראשית +text:"הבל"^2.0 +(דמי OR דמים) -הבלים
+6. Mixed: (text:"רבנו משה"^2.0 OR reference:"משנה תורה") AND topics:הלכה) AND text:"תורה המלך"~3 AND NOT topics:מדרש
+
+Tips:
+- Group complex expressions with parentheses
+- Use quotes for exact phrases
+- Add + for required terms, - for excluded terms
+- Boost important terms with ^N
+- use field-specific terms for better results. 
+"""
+
+    def search(self, query: str, num_results: int = 10) -> List[Dict[str, Any]]:
+        """Search the Tantivy index with the given query using Tantivy's query syntax"""
+        try:
+            # Create a searcher
+            searcher = self.index.searcher()
+     
+            # Parse and execute the query
+            try:
+                # First try with lenient parsing
+                query_parser = self.index.parse_query_lenient(query)
+                search_results = searcher.search(query_parser[0], num_results).hits
+                
+            except Exception as query_error:
+                self.logger.error(f"Lenient query parsing failed: {query_error}")
+            
+            # Process results
+            results = []
+            for score, doc_address in search_results:
+                doc = searcher.doc(doc_address)
+                text = doc.get_first("text")
+                
+                # Extract highlighted snippets based on query terms
+                # Remove special syntax for highlighting while preserving Hebrew
+                highlight_terms = re.sub(
+                    r'[:"()[\]{}^~*\\]|\b(AND|OR|NOT|TO|IN)\b|[-+]', 
+                    ' ', 
+                    query
+                ).strip()
+                highlight_terms = [term for term in highlight_terms.split() if len(term) > 1]
+                
+                # Create regex pattern for highlighting
+                if highlight_terms:
+                    # Escape regex special chars but preserve Hebrew
+                    patterns = [re.escape(term) for term in highlight_terms]
+                    pattern = '|'.join(patterns)
+                    # Get surrounding context for matches
+                    matches = list(re.finditer(pattern, text, re.IGNORECASE))
+                    if matches:
+                        highlights = []
+                        for match in matches:
+                            start = max(0, match.start() - 50)
+                            end = min(len(text), match.end() + 50)
+                            highlight = text[start:end]
+                            if start > 0:
+                                highlight = f"...{highlight}"
+                            if end < len(text):
+                                highlight = f"{highlight}..."
+                            highlights.append(highlight)
+                    else:
+                        highlights = [text[:100] + "..." if len(text) > 100 else text]
+                else:
+                    highlights = [text[:100] + "..." if len(text) > 100 else text]
+                
+                result = {
+                    "score": float(score),
+                    "title": doc.get_first("title") or os.path.basename(doc.get_first("filePath") or ""),
+                    "reference": doc.get_first("reference"),
+                    "topics": doc.get_first("topics"),
+                    "file_path": doc.get_first("filePath"),
+                    "line_number": doc.get_first("segment"),
+                    "is_pdf": doc.get_first("isPdf"),
+                    "text": text,
+                    "highlights": highlights
+                }
+                results.append(result)
+            
+            self.logger.info(f"Found {len(results)} results for query: {query}")
+            return results
+            
+        except Exception as e:
+            self.logger.error(f"Error during search: {str(e)}")
+            return []
+
+    def validate_index(self) -> bool:
+        """Validate that the index exists and is accessible"""
+        try:
+            # Try to create a searcher and perform a simple search
+            searcher = self.index.searcher()
+            query_parser = self.index.parse_query("*")
+            searcher.search(query_parser, 1)
+            return True
+        except Exception as e:
+            self.logger.error(f"Index validation failed: {e}")
+            return False

tools.py

@@ -0,0 +1,118 @@
+from langchain_core.tools import tool
+from sefaria import get_text as sefaria_get_text, get_commentaries as sefaria_get_commentaries
+from tantivy_search import TantivySearch
+from typing import Optional
+from pydantic import BaseModel, Field
+
+from app import INDEX_PATH
+
+class ReadTextArgs(BaseModel):
+        reference: str = Field(description="The reference to retrieve the text for. examples: בראשית א פרק א, Genesis 1:1")
+
+class SearchArgs(BaseModel):
+        query: str = Field(description="""the query for the search.
+    Instructions for generating a query:
+
+    1. Boolean Operators:
+
+    - AND: term1 AND term2 (both required)
+    - OR: term1 OR term2 (either term)
+    - Multiple words default to OR operation (cloud network = cloud OR network)
+    - AND takes precedence over OR
+    - Example: Shabath AND (walk OR go)
+
+    2. Field-specific Terms:
+    - Field-specific terms: field:term
+    - Example: text:אדם AND reference:בראשית
+    - available fields: text, reference, topics
+    - text contains the text of the document
+    - reference contains the citation of the document, e.g. בראשית, פרק א
+    - topics contains the topics of the document. available topics includes: תנך, הלכה, מדרש, etc.
+
+    3. Required/Excluded Terms:
+    - Required (+): +term (must contain)
+    - Excluded (-): -term (must not contain)
+    - Example: +security cloud -deprecated
+    - Equivalent to: security AND cloud AND NOT deprecated
+
+    4. Phrase Search:
+    - Use quotes: "exact phrase"
+    - Both single/double quotes work
+    - Escape quotes with \\"
+    - Slop operator: "term1 term2"~N 
+    - Example: "cloud security"~2 
+    - the above will find "cloud framework and security "
+    - Prefix matching: "start of phrase"*
+
+    5. Wildcards:
+    - ? for single character
+    - * for any number of characters
+    - Example: sec?rity cloud*
+
+    6. Special Features:
+    - All docs: * 
+    - Boost terms: term^2.0 (positive numbers only)
+    - Example: security^2.0 cloud
+    - the above will boost security by 2.0
+    
+    Query Examples:
+    1. Basic: +שבת +חולה +אסור
+    2. Field-specific: text:סיני AND topics:תנך
+    3. Phrase with slop: "security framework"~2
+    4. Complex: +reference:בראשית +text:"הבל"^2.0 +(דמי OR דמים) -הבלים
+    6. Mixed: (text:"רבנו משה"^2.0 OR reference:"משנה תורה") AND topics:הלכה) AND text:"תורה המלך"~3 AND NOT topics:מדרש
+
+    Tips:
+    - Group complex expressions with parentheses
+    - Use quotes for exact phrases
+    - Add + for required terms, - for excluded terms
+    - Boost important terms with ^N
+    - use field-specific terms for better results. 
+    - the corpus to search in is an ancient Hebrew corpus: Tora and Talmud. so Try to use ancient Hebrew terms and or Talmudic expressions and prevent modern words that are not common in talmudic texts
+    """)
+        num_results: int = Field(description="the maximum number of results to return. Default: 10", default=10)
+
+
+
+index_path = INDEX_PATH
+try:
+    tantivy = TantivySearch(index_path)
+    tantivy.validate_index()    
+except Exception as e:
+    raise Exception(f"failed to create index: {e}")
+        
+            
+    
+@tool(args_schema=SearchArgs)
+def search( query: str, num_results: int = 10):
+    """Searches the index for the given query."""
+    results = tantivy.search(query, num_results)
+    formatted_results = []
+    for result in results:
+        formatted_results.append({
+            'text': result.get('text', 'N/A'),
+            'reference': result.get('reference', 'N/A')
+        })
+            
+    return formatted_results
+
+
+@tool(args_schema=ReadTextArgs)
+def read_text(reference: str )->str:
+    """Retrieves the text for a given reference.  
+    """
+    text = sefaria_get_text(reference)
+    return {
+        'text': str(text),
+        'reference': reference
+    }
+
+@tool
+def get_commentaries(reference: str, num_results: int = 10)->str:
+    """Retrieves references to all available commentaries on the given verse."""
+    commentaries = sefaria_get_commentaries(reference)
+    return {
+        'text': '\n'.join(commentaries) if isinstance(commentaries, list) else str(commentaries),
+        'reference': f"Commentaries on {reference}"
+    }
+