khoj 1.23.1.dev1__py3-none-any.whl → 1.23.4.dev1__py3-none-any.whl

khoj/routers/helpers.py

@@ -21,7 +21,7 @@ from typing import (
     Tuple,
     Union,
 )
-from urllib.parse import parse_qs, urljoin, urlparse
+from urllib.parse import parse_qs, quote, urljoin, urlparse
 
 import cron_descriptor
 import pytz
@@ -632,6 +632,7 @@ async def send_message_to_model_wrapper(
             messages=truncated_messages,
             loaded_model=loaded_model,
             model=chat_model,
+            max_prompt_size=max_tokens,
             streaming=False,
             response_type=response_type,
         )
@@ -721,6 +722,7 @@ def send_message_to_model_wrapper_sync(
             system_message=system_message,
             model_name=chat_model,
             loaded_model=loaded_model,
+            max_prompt_size=max_tokens,
             vision_enabled=vision_available,
             model_type=conversation_config.model_type,
         )
@@ -729,6 +731,7 @@ def send_message_to_model_wrapper_sync(
             messages=truncated_messages,
             loaded_model=loaded_model,
             model=chat_model,
+            max_prompt_size=max_tokens,
             streaming=False,
             response_type=response_type,
         )
@@ -739,6 +742,7 @@ def send_message_to_model_wrapper_sync(
             user_message=message,
             system_message=system_message,
             model_name=chat_model,
+            max_prompt_size=max_tokens,
             vision_enabled=vision_available,
             model_type=conversation_config.model_type,
         )
@@ -795,7 +799,7 @@ def generate_chat_response(
     conversation_commands: List[ConversationCommand] = [ConversationCommand.Default],
     user: KhojUser = None,
     client_application: ClientApplication = None,
-    conversation_id: int = None,
+    conversation_id: str = None,
     location_data: LocationData = None,
     user_name: Optional[str] = None,
     uploaded_image_url: Optional[str] = None,
@@ -1098,7 +1102,7 @@ def scheduled_chat(
     user: KhojUser,
     calling_url: URL,
     job_id: str = None,
-    conversation_id: int = None,
+    conversation_id: str = None,
 ):
     logger.info(f"Processing scheduled_chat: {query_to_run}")
     if job_id:
@@ -1127,7 +1131,8 @@ def scheduled_chat(
 
     # Replace the original conversation_id with the conversation_id
     if conversation_id:
-        query_dict["conversation_id"] = [conversation_id]
+        # encode the conversation_id to avoid any issues with special characters
+        query_dict["conversation_id"] = [quote(conversation_id)]
 
     # Restructure the original query_dict into a valid JSON payload for the chat API
     json_payload = {key: values[0] for key, values in query_dict.items()}
@@ -1181,7 +1186,7 @@ def scheduled_chat(
 
 
 async def create_automation(
-    q: str, timezone: str, user: KhojUser, calling_url: URL, meta_log: dict = {}, conversation_id: int = None
+    q: str, timezone: str, user: KhojUser, calling_url: URL, meta_log: dict = {}, conversation_id: str = None
 ):
     crontime, query_to_run, subject = await schedule_query(q, meta_log)
     job = await schedule_automation(query_to_run, subject, crontime, timezone, q, user, calling_url, conversation_id)
@@ -1196,7 +1201,7 @@ async def schedule_automation(
     scheduling_request: str,
     user: KhojUser,
     calling_url: URL,
-    conversation_id: int,
+    conversation_id: str,
 ):
     # Disable minute level automation recurrence
     minute_value = crontime.split(" ")[0]
@@ -1214,7 +1219,7 @@ async def schedule_automation(
             "scheduling_request": scheduling_request,
             "subject": subject,
             "crontime": crontime,
-            "conversation_id": conversation_id,
+            "conversation_id": str(conversation_id),
         }
     )
     query_id = hashlib.md5(f"{query_to_run}_{crontime}".encode("utf-8")).hexdigest()

khoj/utils/cli.py

@@ -50,6 +50,12 @@ def cli(args=None):
         default=False,
         help="Run Khoj in anonymous mode. This does not require any login for connecting users.",
     )
+    parser.add_argument(
+        "--non-interactive",
+        action="store_true",
+        default=False,
+        help="Start Khoj in non-interactive mode. Assumes interactive shell unavailable for config. E.g when run via Docker.",
+    )
 
     args, remaining_args = parser.parse_known_args(args)
 

khoj/utils/constants.py

@@ -8,8 +8,15 @@ empty_escape_sequences = "\n|\r|\t| "
 app_env_filepath = "~/.khoj/env"
 telemetry_server = "https://khoj.beta.haletic.com/v1/telemetry"
 content_directory = "~/.khoj/content/"
-default_offline_chat_model = "bartowski/Meta-Llama-3.1-8B-Instruct-GGUF"
-default_online_chat_model = "gpt-4o-mini"
+default_offline_chat_models = [
+    "bartowski/Meta-Llama-3.1-8B-Instruct-GGUF",
+    "bartowski/gemma-2-9b-it-GGUF",
+    "bartowski/gemma-2-2b-it-GGUF",
+    "bartowski/Phi-3.5-mini-instruct-GGUF",
+]
+default_openai_chat_models = ["gpt-4o-mini", "gpt-4o"]
+default_gemini_chat_models = ["gemini-1.5-flash", "gemini-1.5-pro"]
+default_anthropic_chat_models = ["claude-3-5-sonnet-20240620", "claude-3-opus-20240229"]
 
 empty_config = {
     "search-type": {

khoj/utils/initialization.py

@@ -1,25 +1,37 @@
 import logging
 import os
+from typing import Tuple
 
 from khoj.database.adapters import ConversationAdapters
 from khoj.database.models import (
     ChatModelOptions,
     KhojUser,
     OpenAIProcessorConversationConfig,
+    ServerChatSettings,
     SpeechToTextModelOptions,
     TextToImageModelConfig,
 )
 from khoj.processor.conversation.utils import model_to_prompt_size, model_to_tokenizer
-from khoj.utils.constants import default_offline_chat_model, default_online_chat_model
+from khoj.utils.constants import (
+    default_anthropic_chat_models,
+    default_gemini_chat_models,
+    default_offline_chat_models,
+    default_openai_chat_models,
+)
 
 logger = logging.getLogger(__name__)
 
 
-def initialization():
+def initialization(interactive: bool = True):
     def _create_admin_user():
         logger.info(
             "👩‍✈️ Setting up admin user. These credentials will allow you to configure your server at /server/admin."
         )
+        if not interactive and (not os.getenv("KHOJ_ADMIN_EMAIL") or not os.getenv("KHOJ_ADMIN_PASSWORD")):
+            logger.error(
+                "🚨 Admin user cannot be created. Please set the KHOJ_ADMIN_EMAIL, KHOJ_ADMIN_PASSWORD environment variables or start server in interactive mode."
+            )
+            exit(1)
         email_addr = os.getenv("KHOJ_ADMIN_EMAIL") or input("Email: ")
         password = os.getenv("KHOJ_ADMIN_PASSWORD") or input("Password: ")
         admin_user = KhojUser.objects.create_superuser(email=email_addr, username=email_addr, password=password)
@@ -27,87 +39,103 @@ def initialization():
 
     def _create_chat_configuration():
         logger.info(
-            "🗣️  Configure chat models available to your server. You can always update these at /server/admin using the credentials of your admin account"
+            "🗣️ Configure chat models available to your server. You can always update these at /server/admin using your admin account"
         )
 
-        try:
-            use_offline_model = input("Use offline chat model? (y/n): ")
-            if use_offline_model == "y":
-                logger.info("🗣️ Setting up offline chat model")
-
-                offline_chat_model = input(
-                    f"Enter the offline chat model you want to use. See HuggingFace for available GGUF models (default: {default_offline_chat_model}): "
-                )
-                if offline_chat_model == "":
-                    ChatModelOptions.objects.create(
-                        chat_model=default_offline_chat_model, model_type=ChatModelOptions.ModelType.OFFLINE
-                    )
-                else:
-                    default_max_tokens = model_to_prompt_size.get(offline_chat_model, 2000)
-                    max_tokens = input(
-                        f"Enter the maximum number of tokens to use for the offline chat model (default {default_max_tokens}):"
-                    )
-                    max_tokens = max_tokens or default_max_tokens
-
-                    default_tokenizer = model_to_tokenizer.get(
-                        offline_chat_model, "hf-internal-testing/llama-tokenizer"
-                    )
-                    tokenizer = input(
-                        f"Enter the tokenizer to use for the offline chat model (default: {default_tokenizer}):"
-                    )
-                    tokenizer = tokenizer or default_tokenizer
-
-                    ChatModelOptions.objects.create(
-                        chat_model=offline_chat_model,
-                        model_type=ChatModelOptions.ModelType.OFFLINE,
-                        max_prompt_size=max_tokens,
-                        tokenizer=tokenizer,
-                    )
-        except ModuleNotFoundError as e:
-            logger.warning("Offline models are not supported on this device.")
-
-        use_openai_model = input("Use OpenAI models? (y/n): ")
-        if use_openai_model == "y":
-            logger.info("🗣️ Setting up your OpenAI configuration")
-            api_key = input("Enter your OpenAI API key: ")
-            OpenAIProcessorConversationConfig.objects.create(api_key=api_key)
-
-            openai_chat_model = input(
-                f"Enter the OpenAI chat model you want to use (default: {default_online_chat_model}): "
-            )
-            openai_chat_model = openai_chat_model or default_online_chat_model
-
-            default_max_tokens = model_to_prompt_size.get(openai_chat_model, 2000)
-            max_tokens = input(
-                f"Enter the maximum number of tokens to use for the OpenAI chat model (default: {default_max_tokens}): "
-            )
-            max_tokens = max_tokens or default_max_tokens
-            ChatModelOptions.objects.create(
-                chat_model=openai_chat_model, model_type=ChatModelOptions.ModelType.OPENAI, max_prompt_size=max_tokens
-            )
+        # Set up OpenAI's online chat models
+        openai_configured, openai_provider = _setup_chat_model_provider(
+            ChatModelOptions.ModelType.OPENAI,
+            default_openai_chat_models,
+            default_api_key=os.getenv("OPENAI_API_KEY"),
+            vision_enabled=True,
+            is_offline=False,
+            interactive=interactive,
+        )
 
+        # Setup OpenAI speech to text model
+        if openai_configured:
             default_speech2text_model = "whisper-1"
-            openai_speech2text_model = input(
-                f"Enter the OpenAI speech to text model you want to use (default: {default_speech2text_model}): "
-            )
-            openai_speech2text_model = openai_speech2text_model or default_speech2text_model
+            if interactive:
+                openai_speech2text_model = input(
+                    f"Enter the OpenAI speech to text model you want to use (default: {default_speech2text_model}): "
+                )
+                openai_speech2text_model = openai_speech2text_model or default_speech2text_model
+            else:
+                openai_speech2text_model = default_speech2text_model
             SpeechToTextModelOptions.objects.create(
                 model_name=openai_speech2text_model, model_type=SpeechToTextModelOptions.ModelType.OPENAI
             )
 
+        # Setup OpenAI text to image model
+        if openai_configured:
             default_text_to_image_model = "dall-e-3"
-            openai_text_to_image_model = input(
-                f"Enter the OpenAI text to image model you want to use (default: {default_text_to_image_model}): "
-            )
-            openai_speech2text_model = openai_text_to_image_model or default_text_to_image_model
+            if interactive:
+                openai_text_to_image_model = input(
+                    f"Enter the OpenAI text to image model you want to use (default: {default_text_to_image_model}): "
+                )
+                openai_text_to_image_model = openai_text_to_image_model or default_text_to_image_model
+            else:
+                openai_text_to_image_model = default_text_to_image_model
             TextToImageModelConfig.objects.create(
-                model_name=openai_text_to_image_model, model_type=TextToImageModelConfig.ModelType.OPENAI
+                model_name=openai_text_to_image_model,
+                model_type=TextToImageModelConfig.ModelType.OPENAI,
+                openai_config=openai_provider,
             )
 
-        if use_offline_model == "y" or use_openai_model == "y":
-            logger.info("🗣️  Chat model configuration complete")
+        # Set up Google's Gemini online chat models
+        _setup_chat_model_provider(
+            ChatModelOptions.ModelType.GOOGLE,
+            default_gemini_chat_models,
+            default_api_key=os.getenv("GEMINI_API_KEY"),
+            vision_enabled=False,
+            is_offline=False,
+            interactive=interactive,
+            provider_name="Google Gemini",
+        )
 
-        use_offline_speech2text_model = input("Use offline speech to text model? (y/n): ")
+        # Set up Anthropic's online chat models
+        _setup_chat_model_provider(
+            ChatModelOptions.ModelType.ANTHROPIC,
+            default_anthropic_chat_models,
+            default_api_key=os.getenv("ANTHROPIC_API_KEY"),
+            vision_enabled=False,
+            is_offline=False,
+            interactive=interactive,
+        )
+
+        # Set up offline chat models
+        _setup_chat_model_provider(
+            ChatModelOptions.ModelType.OFFLINE,
+            default_offline_chat_models,
+            default_api_key=None,
+            vision_enabled=False,
+            is_offline=True,
+            interactive=interactive,
+        )
+
+        # Explicitly set default chat model
+        chat_models_configured = ChatModelOptions.objects.count()
+        if chat_models_configured > 0:
+            default_chat_model_name = ChatModelOptions.objects.first().chat_model
+            # If there are multiple chat models, ask the user to choose the default chat model
+            if chat_models_configured > 1 and interactive:
+                user_chat_model_name = input(
+                    f"Enter the default chat model to use (default: {default_chat_model_name}): "
+                )
+            else:
+                user_chat_model_name = None
+
+            # If the user's choice is valid, set it as the default chat model
+            if user_chat_model_name and ChatModelOptions.objects.filter(chat_model=user_chat_model_name).exists():
+                default_chat_model_name = user_chat_model_name
+
+            # Create a server chat settings object with the default chat model
+            default_chat_model = ChatModelOptions.objects.filter(chat_model=default_chat_model_name).first()
+            ServerChatSettings.objects.create(chat_default=default_chat_model)
+            logger.info("🗣️ Chat model configuration complete")
+
+        # Set up offline speech to text model
+        use_offline_speech2text_model = "n" if not interactive else input("Use offline speech to text model? (y/n): ")
         if use_offline_speech2text_model == "y":
             logger.info("🗣️ Setting up offline speech to text model")
             # Delete any existing speech to text model options. There can only be one.
@@ -124,6 +152,64 @@ def initialization():
 
             logger.info(f"🗣️  Offline speech to text model configured to {offline_speech2text_model}")
 
+    def _setup_chat_model_provider(
+        model_type: ChatModelOptions.ModelType,
+        default_chat_models: list,
+        default_api_key: str,
+        interactive: bool,
+        vision_enabled: bool = False,
+        is_offline: bool = False,
+        provider_name: str = None,
+    ) -> Tuple[bool, OpenAIProcessorConversationConfig]:
+        supported_vision_models = ["gpt-4o-mini", "gpt-4o"]
+        provider_name = provider_name or model_type.name.capitalize()
+        default_use_model = {True: "y", False: "n"}[default_api_key is not None or is_offline]
+        use_model_provider = (
+            default_use_model if not interactive else input(f"Add {provider_name} chat models? (y/n): ")
+        )
+
+        if use_model_provider != "y":
+            return False, None
+
+        logger.info(f"️💬 Setting up your {provider_name} chat configuration")
+
+        chat_model_provider = None
+        if not is_offline:
+            if interactive:
+                user_api_key = input(f"Enter your {provider_name} API key (default: {default_api_key}): ")
+                api_key = user_api_key if user_api_key != "" else default_api_key
+            else:
+                api_key = default_api_key
+            chat_model_provider = OpenAIProcessorConversationConfig.objects.create(api_key=api_key, name=provider_name)
+
+        if interactive:
+            chat_model_names = input(
+                f"Enter the {provider_name} chat models you want to use (default: {','.join(default_chat_models)}): "
+            )
+            chat_models = chat_model_names.split(",") if chat_model_names != "" else default_chat_models
+            chat_models = [model.strip() for model in chat_models]
+        else:
+            chat_models = default_chat_models
+
+        for chat_model in chat_models:
+            default_max_tokens = model_to_prompt_size.get(chat_model)
+            default_tokenizer = model_to_tokenizer.get(chat_model)
+            vision_enabled = vision_enabled and chat_model in supported_vision_models
+
+            chat_model_options = {
+                "chat_model": chat_model,
+                "model_type": model_type,
+                "max_prompt_size": default_max_tokens,
+                "vision_enabled": vision_enabled,
+                "tokenizer": default_tokenizer,
+                "openai_config": chat_model_provider,
+            }
+
+            ChatModelOptions.objects.create(**chat_model_options)
+
+        logger.info(f"🗣️ {provider_name} chat model configuration complete")
+        return True, chat_model_provider
+
     admin_user = KhojUser.objects.filter(is_staff=True).first()
     if admin_user is None:
         while True:
@@ -139,7 +225,8 @@ def initialization():
             try:
                 _create_chat_configuration()
                 break
-            # Some environments don't support interactive input. We catch the exception and return if that's the case. The admin can still configure their settings from the admin page.
+            # Some environments don't support interactive input. We catch the exception and return if that's the case.
+            # The admin can still configure their settings from the admin page.
             except EOFError:
                 return
             except Exception as e:

{khoj-1.23.1.dev1.dist-info → khoj-1.23.4.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: khoj
-Version: 1.23.1.dev1
+Version: 1.23.4.dev1
 Summary: Your Second Brain
 Project-URL: Homepage, https://khoj.dev
 Project-URL: Documentation, https://docs.khoj.dev
@@ -61,7 +61,7 @@ Requires-Dist: pymupdf>=1.23.5
 Requires-Dist: python-multipart>=0.0.7
 Requires-Dist: pytz~=2024.1
 Requires-Dist: pyyaml~=6.0
-Requires-Dist: rapidocr-onnxruntime==1.3.22
+Requires-Dist: rapidocr-onnxruntime==1.3.24
 Requires-Dist: requests>=2.26.0
 Requires-Dist: rich>=13.3.1
 Requires-Dist: schedule==1.1.0