khoj 1.42.2.dev1__py3-none-any.whl → 1.42.2.dev16__py3-none-any.whl

khoj/routers/helpers.py

@@ -1,12 +1,13 @@
 import base64
+import concurrent.futures
 import hashlib
 import json
 import logging
 import math
 import os
 import re
+import time
 from datetime import datetime, timedelta, timezone
-from functools import partial
 from random import random
 from typing import (
     Annotated,
@@ -46,6 +47,7 @@ from khoj.database.adapters import (
     aget_user_by_email,
     ais_user_subscribed,
     create_khoj_token,
+    get_default_search_model,
     get_khoj_tokens,
     get_user_name,
     get_user_notion_config,
@@ -101,12 +103,16 @@ from khoj.processor.conversation.utils import (
     clean_json,
     clean_mermaidjs,
     construct_chat_history,
+    construct_question_history,
+    defilter_query,
     generate_chatml_messages_with_context,
-    save_to_conversation_log,
 )
 from khoj.processor.speech.text_to_speech import is_eleven_labs_enabled
 from khoj.routers.email import is_resend_enabled, send_task_email
 from khoj.routers.twilio import is_twilio_enabled
+from khoj.search_filter.date_filter import DateFilter
+from khoj.search_filter.file_filter import FileFilter
+from khoj.search_filter.word_filter import WordFilter
 from khoj.search_type import text_search
 from khoj.utils import state
 from khoj.utils.config import OfflineChatProcessorModel
@@ -123,7 +129,13 @@ from khoj.utils.helpers import (
     timer,
     tool_descriptions_for_llm,
 )
-from khoj.utils.rawconfig import ChatRequestBody, FileAttachment, FileData, LocationData
+from khoj.utils.rawconfig import (
+    ChatRequestBody,
+    FileAttachment,
+    FileData,
+    LocationData,
+    SearchResponse,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -237,8 +249,6 @@ def get_next_url(request: Request) -> str:
 def get_conversation_command(query: str) -> ConversationCommand:
     if query.startswith("/notes"):
         return ConversationCommand.Notes
-    elif query.startswith("/help"):
-        return ConversationCommand.Help
     elif query.startswith("/general"):
         return ConversationCommand.General
     elif query.startswith("/online"):
@@ -249,8 +259,6 @@ def get_conversation_command(query: str) -> ConversationCommand:
         return ConversationCommand.Image
     elif query.startswith("/automated_task"):
         return ConversationCommand.AutomatedTask
-    elif query.startswith("/summarize"):
-        return ConversationCommand.Summarize
     elif query.startswith("/diagram"):
         return ConversationCommand.Diagram
     elif query.startswith("/code"):
@@ -380,9 +388,6 @@ async def aget_data_sources_and_output_format(
     agent_outputs = agent.output_modes if agent else []
 
     for output, description in mode_descriptions_for_llm.items():
-        # Do not allow tasks to schedule another task
-        if is_task and output == ConversationCommand.Automation:
-            continue
         output_options[output.value] = description
         if len(agent_outputs) == 0 or output.value in agent_outputs:
             output_options_str += f'- "{output.value}": "{description}"\n'
@@ -1151,6 +1156,276 @@ async def generate_better_image_prompt(
     return response
 
 
+async def search_documents(
+    user: KhojUser,
+    chat_history: list[ChatMessageModel],
+    q: str,
+    n: int,
+    d: float,
+    conversation_id: str,
+    conversation_commands: List[ConversationCommand] = [ConversationCommand.Default],
+    location_data: LocationData = None,
+    send_status_func: Optional[Callable] = None,
+    query_images: Optional[List[str]] = None,
+    previous_inferred_queries: Set = set(),
+    agent: Agent = None,
+    query_files: str = None,
+    tracer: dict = {},
+):
+    # Initialize Variables
+    compiled_references: List[dict[str, str]] = []
+    inferred_queries: List[str] = []
+
+    agent_has_entries = False
+
+    if agent:
+        agent_has_entries = await sync_to_async(EntryAdapters.agent_has_entries)(agent=agent)
+
+    if (
+        not ConversationCommand.Notes in conversation_commands
+        and not ConversationCommand.Default in conversation_commands
+        and not agent_has_entries
+    ):
+        yield compiled_references, inferred_queries, q
+        return
+
+    # If Notes or Default is not in the conversation command, then the search should be restricted to the agent's knowledge base
+    should_limit_to_agent_knowledge = (
+        ConversationCommand.Notes not in conversation_commands
+        and ConversationCommand.Default not in conversation_commands
+    )
+
+    if not await sync_to_async(EntryAdapters.user_has_entries)(user=user):
+        if not agent_has_entries:
+            logger.debug("No documents in knowledge base. Use a Khoj client to sync and chat with your docs.")
+            yield compiled_references, inferred_queries, q
+            return
+
+    # Extract filter terms from user message
+    defiltered_query = defilter_query(q)
+    filters_in_query = q.replace(defiltered_query, "").strip()
+    conversation = await sync_to_async(ConversationAdapters.get_conversation_by_id)(conversation_id)
+
+    if not conversation:
+        logger.error(f"Conversation with id {conversation_id} not found when extracting references.")
+        yield compiled_references, inferred_queries, defiltered_query
+        return
+
+    filters_in_query += " ".join([f'file:"{filter}"' for filter in conversation.file_filters])
+    if is_none_or_empty(filters_in_query):
+        logger.debug(f"Filters in query: {filters_in_query}")
+
+    personality_context = prompts.personality_context.format(personality=agent.personality) if agent else ""
+
+    # Infer search queries from user message
+    with timer("Extracting search queries took", logger):
+        inferred_queries = await extract_questions(
+            query=defiltered_query,
+            user=user,
+            personality_context=personality_context,
+            chat_history=chat_history,
+            location_data=location_data,
+            query_images=query_images,
+            query_files=query_files,
+            tracer=tracer,
+        )
+
+    # Collate search results as context for the LLM
+    inferred_queries = list(set(inferred_queries) - previous_inferred_queries)
+    with timer("Searching knowledge base took", logger):
+        search_results = []
+        logger.info(f"🔍 Searching knowledge base with queries: {inferred_queries}")
+        if send_status_func:
+            inferred_queries_str = "\n- " + "\n- ".join(inferred_queries)
+            async for event in send_status_func(f"**Searching Documents for:** {inferred_queries_str}"):
+                yield {ChatEvent.STATUS: event}
+        for query in inferred_queries:
+            search_results.extend(
+                await execute_search(
+                    user if not should_limit_to_agent_knowledge else None,
+                    f"{query} {filters_in_query}",
+                    n=n,
+                    t=state.SearchType.All,
+                    r=True,
+                    max_distance=d,
+                    dedupe=False,
+                    agent=agent,
+                )
+            )
+        search_results = text_search.deduplicated_search_responses(search_results)
+        compiled_references = [
+            {"query": q, "compiled": item.additional["compiled"], "file": item.additional["file"]}
+            for q, item in zip(inferred_queries, search_results)
+        ]
+
+    yield compiled_references, inferred_queries, defiltered_query
+
+
+async def extract_questions(
+    query: str,
+    user: KhojUser,
+    personality_context: str = "",
+    chat_history: List[ChatMessageModel] = [],
+    location_data: LocationData = None,
+    query_images: Optional[List[str]] = None,
+    query_files: str = None,
+    tracer: dict = {},
+):
+    """
+    Infer document search queries from user message and provided context
+    """
+    # Shared context setup
+    location = f"{location_data}" if location_data else "N/A"
+    username = prompts.user_name.format(name=user.get_full_name()) if user and user.get_full_name() else ""
+
+    # Date variables for prompt formatting
+    today = datetime.today()
+    current_new_year = today.replace(month=1, day=1)
+    last_new_year = current_new_year.replace(year=today.year - 1)
+    yesterday = (today - timedelta(days=1)).strftime("%Y-%m-%d")
+
+    # Common prompt setup for API-based models (using Anthropic prompts for consistency)
+    chat_history_str = construct_question_history(chat_history, query_prefix="User", agent_name="Assistant")
+
+    system_prompt = prompts.extract_questions_system_prompt.format(
+        current_date=today.strftime("%Y-%m-%d"),
+        day_of_week=today.strftime("%A"),
+        current_month=today.strftime("%Y-%m"),
+        last_new_year=last_new_year.strftime("%Y"),
+        last_new_year_date=last_new_year.strftime("%Y-%m-%d"),
+        current_new_year_date=current_new_year.strftime("%Y-%m-%d"),
+        yesterday_date=yesterday,
+        location=location,
+        username=username,
+        personality_context=personality_context,
+    )
+
+    prompt = prompts.extract_questions_user_message.format(text=query, chat_history=chat_history_str)
+
+    class DocumentQueries(BaseModel):
+        """Choose searches to run on user documents."""
+
+        queries: List[str] = Field(..., min_items=1, description="List of search queries to run on user documents.")
+
+    raw_response = await send_message_to_model_wrapper(
+        system_message=system_prompt,
+        query=prompt,
+        query_images=query_images,
+        query_files=query_files,
+        chat_history=chat_history,
+        response_type="json_object",
+        response_schema=DocumentQueries,
+        user=user,
+        tracer=tracer,
+    )
+
+    # Extract questions from the response
+    try:
+        response = clean_json(raw_response)
+        response = pyjson5.loads(response)
+        queries = [q.strip() for q in response["queries"] if q.strip()]
+        if not isinstance(queries, list) or not queries:
+            logger.error(f"Invalid response for constructing subqueries: {response}")
+            return [query]
+        return queries
+    except:
+        logger.warning(f"LLM returned invalid JSON. Falling back to using user message as search query.")
+        return [query]
+
+
+async def execute_search(
+    user: KhojUser,
+    q: str,
+    n: Optional[int] = 5,
+    t: Optional[state.SearchType] = None,
+    r: Optional[bool] = False,
+    max_distance: Optional[Union[float, None]] = None,
+    dedupe: Optional[bool] = True,
+    agent: Optional[Agent] = None,
+):
+    # Run validation checks
+    results: List[SearchResponse] = []
+
+    start_time = time.time()
+
+    # Ensure the agent, if present, is accessible by the user
+    if user and agent and not await AgentAdapters.ais_agent_accessible(agent, user):
+        logger.error(f"Agent {agent.slug} is not accessible by user {user}")
+        return results
+
+    if q is None or q == "":
+        logger.warning(f"No query param (q) passed in API call to initiate search")
+        return results
+
+    # initialize variables
+    user_query = q.strip()
+    results_count = n or 5
+    t = t or state.SearchType.All
+    search_futures: List[concurrent.futures.Future] = []
+
+    # return cached results, if available
+    if user:
+        query_cache_key = f"{user_query}-{n}-{t}-{r}-{max_distance}-{dedupe}"
+        if query_cache_key in state.query_cache[user.uuid]:
+            logger.debug(f"Return response from query cache")
+            return state.query_cache[user.uuid][query_cache_key]
+
+    # Encode query with filter terms removed
+    defiltered_query = user_query
+    for filter in [DateFilter(), WordFilter(), FileFilter()]:
+        defiltered_query = filter.defilter(defiltered_query)
+
+    encoded_asymmetric_query = None
+    if t != state.SearchType.Image:
+        with timer("Encoding query took", logger=logger):
+            search_model = await sync_to_async(get_default_search_model)()
+            encoded_asymmetric_query = state.embeddings_model[search_model.name].embed_query(defiltered_query)
+
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        if t in [
+            state.SearchType.All,
+            state.SearchType.Org,
+            state.SearchType.Markdown,
+            state.SearchType.Github,
+            state.SearchType.Notion,
+            state.SearchType.Plaintext,
+            state.SearchType.Pdf,
+        ]:
+            # query markdown notes
+            search_futures += [
+                executor.submit(
+                    text_search.query,
+                    user_query,
+                    user,
+                    t,
+                    question_embedding=encoded_asymmetric_query,
+                    max_distance=max_distance,
+                    agent=agent,
+                )
+            ]
+
+        # Query across each requested content types in parallel
+        with timer("Query took", logger):
+            for search_future in concurrent.futures.as_completed(search_futures):
+                hits = await search_future.result()
+                # Collate results
+                results += text_search.collate_results(hits, dedupe=dedupe)
+
+                # Sort results across all content types and take top results
+                results = text_search.rerank_and_sort_results(
+                    results, query=defiltered_query, rank_results=r, search_model_name=search_model.name
+                )[:results_count]
+
+    # Cache results
+    if user:
+        state.query_cache[user.uuid][query_cache_key] = results
+
+    end_time = time.time()
+    logger.debug(f"🔍 Search took: {end_time - start_time:.3f} seconds")
+
+    return results
+
+
 async def send_message_to_model_wrapper(
     query: str,
     system_message: str = "",
@@ -1350,54 +1625,24 @@ async def agenerate_chat_response(
     code_results: Dict[str, Dict] = {},
     operator_results: List[OperatorRun] = [],
     research_results: List[ResearchIteration] = [],
-    inferred_queries: List[str] = [],
-    conversation_commands: List[ConversationCommand] = [ConversationCommand.Default],
     user: KhojUser = None,
-    client_application: ClientApplication = None,
     location_data: LocationData = None,
     user_name: Optional[str] = None,
     query_images: Optional[List[str]] = None,
-    train_of_thought: List[Any] = [],
     query_files: str = None,
-    raw_query_files: List[FileAttachment] = None,
-    generated_images: List[str] = None,
     raw_generated_files: List[FileAttachment] = [],
-    generated_mermaidjs_diagram: str = None,
     program_execution_context: List[str] = [],
     generated_asset_results: Dict[str, Dict] = {},
     is_subscribed: bool = False,
     tracer: dict = {},
-) -> Tuple[AsyncGenerator[str | ResponseWithThought, None], Dict[str, str]]:
+) -> Tuple[AsyncGenerator[ResponseWithThought, None], Dict[str, str]]:
     # Initialize Variables
-    chat_response_generator: AsyncGenerator[str | ResponseWithThought, None] = None
-    logger.debug(f"Conversation Types: {conversation_commands}")
+    chat_response_generator: AsyncGenerator[ResponseWithThought, None] = None
 
     metadata = {}
     agent = await AgentAdapters.aget_conversation_agent_by_id(conversation.agent.id) if conversation.agent else None
 
     try:
-        partial_completion = partial(
-            save_to_conversation_log,
-            q,
-            user=user,
-            chat_history=chat_history,
-            compiled_references=compiled_references,
-            online_results=online_results,
-            code_results=code_results,
-            operator_results=operator_results,
-            research_results=research_results,
-            inferred_queries=inferred_queries,
-            client_application=client_application,
-            conversation_id=str(conversation.id),
-            query_images=query_images,
-            train_of_thought=train_of_thought,
-            raw_query_files=raw_query_files,
-            generated_images=generated_images,
-            raw_generated_files=raw_generated_files,
-            generated_mermaidjs_diagram=generated_mermaidjs_diagram,
-            tracer=tracer,
-        )
-
         query_to_run = q
         deepthought = False
         if research_results:
@@ -1421,22 +1666,23 @@ async def agenerate_chat_response(
         if chat_model.model_type == "offline":
             loaded_model = state.offline_chat_processor_config.loaded_model
             chat_response_generator = converse_offline(
+                # Query
                 user_query=query_to_run,
+                # Context
                 references=compiled_references,
                 online_results=online_results,
-                loaded_model=loaded_model,
+                generated_files=raw_generated_files,
+                generated_asset_results=generated_asset_results,
+                location_data=location_data,
+                user_name=user_name,
+                query_files=query_files,
                 chat_history=chat_history,
-                completion_func=partial_completion,
-                conversation_commands=conversation_commands,
+                # Model
+                loaded_model=loaded_model,
                 model_name=chat_model.name,
                 max_prompt_size=chat_model.max_prompt_size,
                 tokenizer_name=chat_model.tokenizer,
-                location_data=location_data,
-                user_name=user_name,
                 agent=agent,
-                query_files=query_files,
-                generated_files=raw_generated_files,
-                generated_asset_results=generated_asset_results,
                 tracer=tracer,
             )
 
@@ -1445,28 +1691,29 @@ async def agenerate_chat_response(
             api_key = openai_chat_config.api_key
             chat_model_name = chat_model.name
             chat_response_generator = converse_openai(
+                # Query
                 query_to_run,
-                compiled_references,
-                query_images=query_images,
+                # Context
+                references=compiled_references,
                 online_results=online_results,
                 code_results=code_results,
                 operator_results=operator_results,
+                query_images=query_images,
+                query_files=query_files,
+                generated_files=raw_generated_files,
+                generated_asset_results=generated_asset_results,
+                program_execution_context=program_execution_context,
+                location_data=location_data,
+                user_name=user_name,
                 chat_history=chat_history,
+                # Model
                 model=chat_model_name,
                 api_key=api_key,
                 api_base_url=openai_chat_config.api_base_url,
-                completion_func=partial_completion,
-                conversation_commands=conversation_commands,
                 max_prompt_size=chat_model.max_prompt_size,
                 tokenizer_name=chat_model.tokenizer,
-                location_data=location_data,
-                user_name=user_name,
                 agent=agent,
                 vision_available=vision_available,
-                query_files=query_files,
-                generated_files=raw_generated_files,
-                generated_asset_results=generated_asset_results,
-                program_execution_context=program_execution_context,
                 deepthought=deepthought,
                 tracer=tracer,
             )
@@ -1475,28 +1722,29 @@ async def agenerate_chat_response(
             api_key = chat_model.ai_model_api.api_key
             api_base_url = chat_model.ai_model_api.api_base_url
             chat_response_generator = converse_anthropic(
+                # Query
                 query_to_run,
-                compiled_references,
-                query_images=query_images,
+                # Context
+                references=compiled_references,
                 online_results=online_results,
                 code_results=code_results,
                 operator_results=operator_results,
+                query_images=query_images,
+                query_files=query_files,
+                generated_files=raw_generated_files,
+                generated_asset_results=generated_asset_results,
+                program_execution_context=program_execution_context,
+                location_data=location_data,
+                user_name=user_name,
                 chat_history=chat_history,
+                # Model
                 model=chat_model.name,
                 api_key=api_key,
                 api_base_url=api_base_url,
-                completion_func=partial_completion,
-                conversation_commands=conversation_commands,
                 max_prompt_size=chat_model.max_prompt_size,
                 tokenizer_name=chat_model.tokenizer,
-                location_data=location_data,
-                user_name=user_name,
                 agent=agent,
                 vision_available=vision_available,
-                query_files=query_files,
-                generated_files=raw_generated_files,
-                generated_asset_results=generated_asset_results,
-                program_execution_context=program_execution_context,
                 deepthought=deepthought,
                 tracer=tracer,
             )
@@ -1504,28 +1752,29 @@ async def agenerate_chat_response(
             api_key = chat_model.ai_model_api.api_key
             api_base_url = chat_model.ai_model_api.api_base_url
             chat_response_generator = converse_gemini(
+                # Query
                 query_to_run,
-                compiled_references,
+                # Context
+                references=compiled_references,
                 online_results=online_results,
                 code_results=code_results,
                 operator_results=operator_results,
+                query_images=query_images,
+                query_files=query_files,
+                generated_files=raw_generated_files,
+                generated_asset_results=generated_asset_results,
+                program_execution_context=program_execution_context,
+                location_data=location_data,
+                user_name=user_name,
                 chat_history=chat_history,
+                # Model
                 model=chat_model.name,
                 api_key=api_key,
                 api_base_url=api_base_url,
-                completion_func=partial_completion,
-                conversation_commands=conversation_commands,
                 max_prompt_size=chat_model.max_prompt_size,
                 tokenizer_name=chat_model.tokenizer,
-                location_data=location_data,
-                user_name=user_name,
                 agent=agent,
-                query_images=query_images,
                 vision_available=vision_available,
-                query_files=query_files,
-                generated_files=raw_generated_files,
-                generated_asset_results=generated_asset_results,
-                program_execution_context=program_execution_context,
                 deepthought=deepthought,
                 tracer=tracer,
             )

khoj/routers/research.py

@@ -22,10 +22,10 @@ from khoj.processor.conversation.utils import (
 from khoj.processor.operator import operate_environment
 from khoj.processor.tools.online_search import read_webpages, search_online
 from khoj.processor.tools.run_code import run_code
-from khoj.routers.api import extract_references_and_questions
 from khoj.routers.helpers import (
     ChatEvent,
     generate_summary_from_files,
+    search_documents,
     send_message_to_model_wrapper,
 )
 from khoj.utils.helpers import (
@@ -273,7 +273,6 @@ async def research(
         code_results: Dict = dict()
         document_results: List[Dict[str, str]] = []
         operator_results: OperatorRun = None
-        summarize_files: str = ""
         this_iteration = ResearchIteration(tool=None, query=query)
 
         async for result in apick_next_tool(
@@ -313,7 +312,7 @@ async def research(
             previous_inferred_queries = {
                 c["query"] for iteration in previous_iterations if iteration.context for c in iteration.context
             }
-            async for result in extract_references_and_questions(
+            async for result in search_documents(
                 user,
                 construct_tool_chat_history(previous_iterations, ConversationCommand.Notes),
                 this_iteration.query,
@@ -473,40 +472,13 @@ async def research(
                 this_iteration.warning = f"Error operating browser: {e}"
                 logger.error(this_iteration.warning, exc_info=True)
 
-        elif this_iteration.tool == ConversationCommand.Summarize:
-            try:
-                async for result in generate_summary_from_files(
-                    this_iteration.query,
-                    user,
-                    file_filters,
-                    construct_tool_chat_history(previous_iterations, ConversationCommand.Summarize),
-                    query_images=query_images,
-                    agent=agent,
-                    send_status_func=send_status_func,
-                    query_files=query_files,
-                ):
-                    if isinstance(result, dict) and ChatEvent.STATUS in result:
-                        yield result[ChatEvent.STATUS]
-                    else:
-                        summarize_files = result  # type: ignore
-            except Exception as e:
-                this_iteration.warning = f"Error summarizing files: {e}"
-                logger.error(this_iteration.warning, exc_info=True)
-
         else:
             # No valid tools. This is our exit condition.
             current_iteration = MAX_ITERATIONS
 
         current_iteration += 1
 
-        if (
-            document_results
-            or online_results
-            or code_results
-            or operator_results
-            or summarize_files
-            or this_iteration.warning
-        ):
+        if document_results or online_results or code_results or operator_results or this_iteration.warning:
             results_data = f"\n<iteration>{current_iteration}\n<tool>{this_iteration.tool}</tool>\n<query>{this_iteration.query}</query>\n<results>"
             if document_results:
                 results_data += f"\n<document_references>\n{yaml.dump(document_results, allow_unicode=True, sort_keys=False, default_flow_style=False)}\n</document_references>"
@@ -518,8 +490,6 @@ async def research(
                 results_data += (
                     f"\n<browser_operator_results>\n{operator_results.response}\n</browser_operator_results>"
                 )
-            if summarize_files:
-                results_data += f"\n<summarized_files>\n{yaml.dump(summarize_files, allow_unicode=True, sort_keys=False, default_flow_style=False)}\n</summarized_files>"
             if this_iteration.warning:
                 results_data += f"\n<warning>\n{this_iteration.warning}\n</warning>"
             results_data += "\n</results>\n</iteration>"

khoj/utils/helpers.py

@@ -338,15 +338,12 @@ class ConversationCommand(str, Enum):
     Default = "default"
     General = "general"
     Notes = "notes"
-    Help = "help"
     Online = "online"
     Webpage = "webpage"
     Code = "code"
     Image = "image"
     Text = "text"
-    Automation = "automation"
     AutomatedTask = "automated_task"
-    Summarize = "summarize"
     Diagram = "diagram"
     Research = "research"
     Operator = "operator"
@@ -360,9 +357,6 @@ command_descriptions = {
     ConversationCommand.Webpage: "Get information from webpage suggested by you.",
     ConversationCommand.Code: "Run Python code to parse information, run complex calculations, create documents and charts.",
     ConversationCommand.Image: "Generate illustrative, creative images by describing your imagination in words.",
-    ConversationCommand.Automation: "Automatically run your query at a specified time or interval.",
-    ConversationCommand.Help: "Get help with how to use or setup Khoj from the documentation",
-    ConversationCommand.Summarize: "Get help with a question pertaining to an entire document.",
     ConversationCommand.Diagram: "Draw a flowchart, diagram, or any other visual representation best expressed with primitives like lines, rectangles, and text.",
     ConversationCommand.Research: "Do deep research on a topic. This will take longer than usual, but give a more detailed, comprehensive answer.",
     ConversationCommand.Operator: "Operate and perform tasks using a computer.",

{khoj-1.42.2.dev1.dist-info → khoj-1.42.2.dev16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: khoj
-Version: 1.42.2.dev1
+Version: 1.42.2.dev16
 Summary: Your Second Brain
 Project-URL: Homepage, https://khoj.dev
 Project-URL: Documentation, https://docs.khoj.dev