khoj 2.0.0b12__py3-none-any.whl → 2.0.0b13.dev5__py3-none-any.whl

khoj/routers/api.py

@@ -15,7 +15,6 @@ from khoj.configure import initialize_content
 from khoj.database import adapters
 from khoj.database.adapters import ConversationAdapters, EntryAdapters, get_user_photo
 from khoj.database.models import KhojUser, SpeechToTextModelOptions
-from khoj.processor.conversation.offline.whisper import transcribe_audio_offline
 from khoj.processor.conversation.openai.whisper import transcribe_audio
 from khoj.routers.helpers import (
     ApiUserRateLimiter,
@@ -88,22 +87,14 @@ def update(
     force: Optional[bool] = False,
 ):
     user = request.user.object
-    if not state.config:
-        error_msg = f"🚨 Khoj is not configured.\nConfigure it via http://localhost:42110/settings, plugins or by editing {state.config_file}."
-        logger.warning(error_msg)
-        raise HTTPException(status_code=500, detail=error_msg)
     try:
         initialize_content(user=user, regenerate=force, search_type=t)
     except Exception as e:
-        error_msg = f"🚨 Failed to update server via API: {e}"
+        error_msg = f"🚨 Failed to update server indexed content via API: {e}"
         logger.error(error_msg, exc_info=True)
         raise HTTPException(status_code=500, detail=error_msg)
     else:
-        components = []
-        if state.search_models:
-            components.append("Search models")
-        components_msg = ", ".join(components)
-        logger.info(f"📪 {components_msg} updated via API")
+        logger.info(f"📪 Server indexed content updated via API")
 
     update_telemetry_state(
         request=request,
@@ -150,9 +141,6 @@ async def transcribe(
         if not speech_to_text_config:
             # If the user has not configured a speech to text model, return an unsupported on server error
             status_code = 501
-        elif speech_to_text_config.model_type == SpeechToTextModelOptions.ModelType.OFFLINE:
-            speech2text_model = speech_to_text_config.model_name
-            user_message = await transcribe_audio_offline(audio_filename, speech2text_model)
         elif speech_to_text_config.model_type == SpeechToTextModelOptions.ModelType.OPENAI:
             speech2text_model = speech_to_text_config.model_name
             if speech_to_text_config.ai_model_api:

khoj/routers/api_content.py

@@ -27,16 +27,7 @@ from khoj.database.adapters import (
     get_user_notion_config,
 )
 from khoj.database.models import Entry as DbEntry
-from khoj.database.models import (
-    GithubConfig,
-    GithubRepoConfig,
-    KhojUser,
-    LocalMarkdownConfig,
-    LocalOrgConfig,
-    LocalPdfConfig,
-    LocalPlaintextConfig,
-    NotionConfig,
-)
+from khoj.database.models import GithubConfig, GithubRepoConfig, NotionConfig
 from khoj.processor.content.docx.docx_to_entries import DocxToEntries
 from khoj.processor.content.pdf.pdf_to_entries import PdfToEntries
 from khoj.routers.helpers import (
@@ -47,17 +38,9 @@ from khoj.routers.helpers import (
     get_user_config,
     update_telemetry_state,
 )
-from khoj.utils import constants, state
-from khoj.utils.config import SearchModels
-from khoj.utils.rawconfig import (
-    ContentConfig,
-    FullConfig,
-    GithubContentConfig,
-    NotionContentConfig,
-    SearchConfig,
-)
+from khoj.utils import state
+from khoj.utils.rawconfig import GithubContentConfig, NotionContentConfig
 from khoj.utils.state import SearchType
-from khoj.utils.yaml import save_config_to_file_updated_state
 
 logger = logging.getLogger(__name__)
 
@@ -192,8 +175,6 @@ async def set_content_github(
     updated_config: Union[GithubContentConfig, None],
     client: Optional[str] = None,
 ):
-    _initialize_config()
-
     user = request.user.object
 
     try:
@@ -225,8 +206,6 @@ async def set_content_notion(
     updated_config: Union[NotionContentConfig, None],
     client: Optional[str] = None,
 ):
-    _initialize_config()
-
     user = request.user.object
 
     try:
@@ -323,10 +302,6 @@ def get_content_types(request: Request, client: Optional[str] = None):
     configured_content_types = set(EntryAdapters.get_unique_file_types(user))
     configured_content_types |= {"all"}
 
-    if state.config and state.config.content_type:
-        for ctype in state.config.content_type.model_dump(exclude_none=True):
-            configured_content_types.add(ctype)
-
     return list(configured_content_types & all_content_types)
 
 
@@ -606,28 +581,6 @@ async def indexer(
             docx=index_files["docx"],
         )
 
-        if state.config == None:
-            logger.info("📬 Initializing content index on first run.")
-            default_full_config = FullConfig(
-                content_type=None,
-                search_type=SearchConfig.model_validate(constants.default_config["search-type"]),
-                processor=None,
-            )
-            state.config = default_full_config
-            default_content_config = ContentConfig(
-                org=None,
-                markdown=None,
-                pdf=None,
-                docx=None,
-                image=None,
-                github=None,
-                notion=None,
-                plaintext=None,
-            )
-            state.config.content_type = default_content_config
-            save_config_to_file_updated_state()
-            configure_search(state.search_models, state.config.search_type)
-
         loop = asyncio.get_event_loop()
         success = await loop.run_in_executor(
             None,
@@ -674,14 +627,6 @@ async def indexer(
     return Response(content=indexed_filenames, status_code=200)
 
 
-def configure_search(search_models: SearchModels, search_config: Optional[SearchConfig]) -> Optional[SearchModels]:
-    # Run Validation Checks
-    if search_models is None:
-        search_models = SearchModels()
-
-    return search_models
-
-
 def map_config_to_object(content_source: str):
     if content_source == DbEntry.EntrySource.GITHUB:
         return GithubConfig
@@ -689,56 +634,3 @@ def map_config_to_object(content_source: str):
         return NotionConfig
     if content_source == DbEntry.EntrySource.COMPUTER:
         return "Computer"
-
-
-async def map_config_to_db(config: FullConfig, user: KhojUser):
-    if config.content_type:
-        if config.content_type.org:
-            await LocalOrgConfig.objects.filter(user=user).adelete()
-            await LocalOrgConfig.objects.acreate(
-                input_files=config.content_type.org.input_files,
-                input_filter=config.content_type.org.input_filter,
-                index_heading_entries=config.content_type.org.index_heading_entries,
-                user=user,
-            )
-        if config.content_type.markdown:
-            await LocalMarkdownConfig.objects.filter(user=user).adelete()
-            await LocalMarkdownConfig.objects.acreate(
-                input_files=config.content_type.markdown.input_files,
-                input_filter=config.content_type.markdown.input_filter,
-                index_heading_entries=config.content_type.markdown.index_heading_entries,
-                user=user,
-            )
-        if config.content_type.pdf:
-            await LocalPdfConfig.objects.filter(user=user).adelete()
-            await LocalPdfConfig.objects.acreate(
-                input_files=config.content_type.pdf.input_files,
-                input_filter=config.content_type.pdf.input_filter,
-                index_heading_entries=config.content_type.pdf.index_heading_entries,
-                user=user,
-            )
-        if config.content_type.plaintext:
-            await LocalPlaintextConfig.objects.filter(user=user).adelete()
-            await LocalPlaintextConfig.objects.acreate(
-                input_files=config.content_type.plaintext.input_files,
-                input_filter=config.content_type.plaintext.input_filter,
-                index_heading_entries=config.content_type.plaintext.index_heading_entries,
-                user=user,
-            )
-        if config.content_type.github:
-            await adapters.set_user_github_config(
-                user=user,
-                pat_token=config.content_type.github.pat_token,
-                repos=config.content_type.github.repos,
-            )
-        if config.content_type.notion:
-            await adapters.set_notion_config(
-                user=user,
-                token=config.content_type.notion.token,
-            )
-
-
-def _initialize_config():
-    if state.config is None:
-        state.config = FullConfig()
-        state.config.search_type = SearchConfig.model_validate(constants.default_config["search-type"])

khoj/routers/helpers.py

@@ -89,10 +89,6 @@ from khoj.processor.conversation.google.gemini_chat import (
     converse_gemini,
     gemini_send_message_to_model,
 )
-from khoj.processor.conversation.offline.chat_model import (
-    converse_offline,
-    send_message_to_model_offline,
-)
 from khoj.processor.conversation.openai.gpt import (
     converse_openai,
     send_message_to_model,
@@ -117,7 +113,6 @@ 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
 from khoj.utils.helpers import (
     LRU,
     ConversationCommand,
@@ -168,14 +163,6 @@ async def is_ready_to_chat(user: KhojUser):
     if user_chat_model == None:
         user_chat_model = await ConversationAdapters.aget_default_chat_model(user)
 
-    if user_chat_model and user_chat_model.model_type == ChatModel.ModelType.OFFLINE:
-        chat_model_name = user_chat_model.name
-        max_tokens = user_chat_model.max_prompt_size
-        if state.offline_chat_processor_config is None:
-            logger.info("Loading Offline Chat Model...")
-            state.offline_chat_processor_config = OfflineChatProcessorModel(chat_model_name, max_tokens)
-        return True
-
     if (
         user_chat_model
         and (
@@ -231,7 +218,6 @@ def update_telemetry_state(
             telemetry_type=telemetry_type,
             api=api,
             client=client,
-            app_config=state.config.app,
             disable_telemetry_env=state.telemetry_disabled,
             properties=user_state,
         )
@@ -1470,12 +1456,6 @@ async def send_message_to_model_wrapper(
     vision_available = chat_model.vision_enabled
     api_key = chat_model.ai_model_api.api_key
     api_base_url = chat_model.ai_model_api.api_base_url
-    loaded_model = None
-
-    if model_type == ChatModel.ModelType.OFFLINE:
-        if state.offline_chat_processor_config is None or state.offline_chat_processor_config.loaded_model is None:
-            state.offline_chat_processor_config = OfflineChatProcessorModel(chat_model_name, max_tokens)
-        loaded_model = state.offline_chat_processor_config.loaded_model
 
     truncated_messages = generate_chatml_messages_with_context(
         user_message=query,
@@ -1483,7 +1463,6 @@ async def send_message_to_model_wrapper(
         system_message=system_message,
         chat_history=chat_history,
         model_name=chat_model_name,
-        loaded_model=loaded_model,
         tokenizer_name=tokenizer,
         max_prompt_size=max_tokens,
         vision_enabled=vision_available,
@@ -1492,18 +1471,7 @@ async def send_message_to_model_wrapper(
         query_files=query_files,
     )
 
-    if model_type == ChatModel.ModelType.OFFLINE:
-        return send_message_to_model_offline(
-            messages=truncated_messages,
-            loaded_model=loaded_model,
-            model_name=chat_model_name,
-            max_prompt_size=max_tokens,
-            streaming=False,
-            response_type=response_type,
-            tracer=tracer,
-        )
-
-    elif model_type == ChatModel.ModelType.OPENAI:
+    if model_type == ChatModel.ModelType.OPENAI:
         return send_message_to_model(
             messages=truncated_messages,
             api_key=api_key,
@@ -1565,19 +1533,12 @@ def send_message_to_model_wrapper_sync(
     vision_available = chat_model.vision_enabled
     api_key = chat_model.ai_model_api.api_key
     api_base_url = chat_model.ai_model_api.api_base_url
-    loaded_model = None
-
-    if model_type == ChatModel.ModelType.OFFLINE:
-        if state.offline_chat_processor_config is None or state.offline_chat_processor_config.loaded_model is None:
-            state.offline_chat_processor_config = OfflineChatProcessorModel(chat_model_name, max_tokens)
-        loaded_model = state.offline_chat_processor_config.loaded_model
 
     truncated_messages = generate_chatml_messages_with_context(
         user_message=message,
         system_message=system_message,
         chat_history=chat_history,
         model_name=chat_model_name,
-        loaded_model=loaded_model,
         max_prompt_size=max_tokens,
         vision_enabled=vision_available,
         model_type=model_type,
@@ -1585,18 +1546,7 @@ def send_message_to_model_wrapper_sync(
         query_files=query_files,
     )
 
-    if model_type == ChatModel.ModelType.OFFLINE:
-        return send_message_to_model_offline(
-            messages=truncated_messages,
-            loaded_model=loaded_model,
-            model_name=chat_model_name,
-            max_prompt_size=max_tokens,
-            streaming=False,
-            response_type=response_type,
-            tracer=tracer,
-        )
-
-    elif model_type == ChatModel.ModelType.OPENAI:
+    if model_type == ChatModel.ModelType.OPENAI:
         return send_message_to_model(
             messages=truncated_messages,
             api_key=api_key,
@@ -1678,30 +1628,7 @@ async def agenerate_chat_response(
                 chat_model = vision_enabled_config
                 vision_available = True
 
-        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,
-                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,
-                # Model
-                loaded_model=loaded_model,
-                model_name=chat_model.name,
-                max_prompt_size=chat_model.max_prompt_size,
-                tokenizer_name=chat_model.tokenizer,
-                agent=agent,
-                tracer=tracer,
-            )
-
-        elif chat_model.model_type == ChatModel.ModelType.OPENAI:
+        if chat_model.model_type == ChatModel.ModelType.OPENAI:
             openai_chat_config = chat_model.ai_model_api
             api_key = openai_chat_config.api_key
             chat_model_name = chat_model.name
@@ -2798,7 +2725,8 @@ def configure_content(
 
     search_type = t.value if t else None
 
-    no_documents = all([not files.get(file_type) for file_type in files])
+    # Check if client sent any documents of the supported types
+    no_client_sent_documents = all([not files.get(file_type) for file_type in files])
 
     if files is None:
         logger.warning(f"🚨 No files to process for {search_type} search.")
@@ -2872,7 +2800,8 @@ def configure_content(
         success = False
 
     try:
-        if no_documents:
+        # Run server side indexing of user Github docs if no client sent documents
+        if no_client_sent_documents:
             github_config = GithubConfig.objects.filter(user=user).prefetch_related("githubrepoconfig").first()
             if (
                 search_type == state.SearchType.All.value or search_type == state.SearchType.Github.value
@@ -2892,7 +2821,8 @@ def configure_content(
         success = False
 
     try:
-        if no_documents:
+        # Run server side indexing of user Notion docs if no client sent documents
+        if no_client_sent_documents:
             # Initialize Notion Search
             notion_config = NotionConfig.objects.filter(user=user).first()
             if (

khoj/utils/cli.py

@@ -1,36 +1,19 @@
 import argparse
 import logging
-import os
 import pathlib
 from importlib.metadata import version
 
 logger = logging.getLogger(__name__)
 
-from khoj.migrations.migrate_offline_chat_default_model import (
-    migrate_offline_chat_default_model,
-)
-from khoj.migrations.migrate_offline_chat_schema import migrate_offline_chat_schema
-from khoj.migrations.migrate_offline_model import migrate_offline_model
-from khoj.migrations.migrate_processor_config_openai import (
-    migrate_processor_conversation_schema,
-)
-from khoj.migrations.migrate_server_pg import migrate_server_pg
-from khoj.migrations.migrate_version import migrate_config_to_version
-from khoj.utils.helpers import is_env_var_true, resolve_absolute_path
-from khoj.utils.yaml import parse_config_from_file
-
 
 def cli(args=None):
     # Setup Argument Parser for the Commandline Interface
     parser = argparse.ArgumentParser(description="Start Khoj; An AI personal assistant for your Digital Brain")
     parser.add_argument(
-        "--config-file", default="~/.khoj/khoj.yml", type=pathlib.Path, help="YAML file to configure Khoj"
-    )
-    parser.add_argument(
-        "--regenerate",
-        action="store_true",
-        default=False,
-        help="Regenerate model embeddings from source files. Default: false",
+        "--log-file",
+        default="~/.khoj/khoj.log",
+        type=pathlib.Path,
+        help="File path for server logs. Default: ~/.khoj/khoj.log",
     )
     parser.add_argument("--verbose", "-v", action="count", default=0, help="Show verbose conversion logs. Default: 0")
     parser.add_argument("--host", type=str, default="127.0.0.1", help="Host address of the server. Default: 127.0.0.1")
@@ -43,14 +26,11 @@ def cli(args=None):
     parser.add_argument("--sslcert", type=str, help="Path to SSL certificate file")
     parser.add_argument("--sslkey", type=str, help="Path to SSL key file")
     parser.add_argument("--version", "-V", action="store_true", help="Print the installed Khoj version and exit")
-    parser.add_argument(
-        "--disable-chat-on-gpu", action="store_true", default=False, help="Disable using GPU for the offline chat model"
-    )
     parser.add_argument(
         "--anonymous-mode",
         action="store_true",
         default=False,
-        help="Run Khoj in anonymous mode. This does not require any login for connecting users.",
+        help="Run Khoj in single user mode with no login required. Useful for personal use or testing.",
     )
     parser.add_argument(
         "--non-interactive",
@@ -64,38 +44,10 @@ def cli(args=None):
     if len(remaining_args) > 0:
         logger.info(f"⚠️  Ignoring unknown commandline args: {remaining_args}")
 
-    # Set default values for arguments
-    args.chat_on_gpu = not args.disable_chat_on_gpu
-
     args.version_no = version("khoj")
     if args.version:
         # Show version of khoj installed and exit
         print(args.version_no)
         exit(0)
 
-    # Normalize config_file path to absolute path
-    args.config_file = resolve_absolute_path(args.config_file)
-
-    if not args.config_file.exists():
-        args.config = None
-    else:
-        args = run_migrations(args)
-        args.config = parse_config_from_file(args.config_file)
-        if is_env_var_true("KHOJ_TELEMETRY_DISABLE"):
-            args.config.app.should_log_telemetry = False
-
-    return args
-
-
-def run_migrations(args):
-    migrations = [
-        migrate_config_to_version,
-        migrate_processor_conversation_schema,
-        migrate_offline_model,
-        migrate_offline_chat_schema,
-        migrate_offline_chat_default_model,
-        migrate_server_pg,
-    ]
-    for migration in migrations:
-        args = migration(args)
     return args

khoj/utils/config.py

@@ -1,22 +1,7 @@
 # System Packages
 from __future__ import annotations  # to avoid quoting type hints
 
-import logging
-from dataclasses import dataclass
 from enum import Enum
-from typing import TYPE_CHECKING, Any, List, Optional, Union
-
-import torch
-
-from khoj.processor.conversation.offline.utils import download_model
-
-logger = logging.getLogger(__name__)
-
-
-if TYPE_CHECKING:
-    from sentence_transformers import CrossEncoder
-
-    from khoj.utils.models import BaseEncoder
 
 
 class SearchType(str, Enum):
@@ -29,53 +14,3 @@ class SearchType(str, Enum):
     Notion = "notion"
     Plaintext = "plaintext"
     Docx = "docx"
-
-
-class ProcessorType(str, Enum):
-    Conversation = "conversation"
-
-
-@dataclass
-class TextContent:
-    enabled: bool
-
-
-@dataclass
-class ImageContent:
-    image_names: List[str]
-    image_embeddings: torch.Tensor
-    image_metadata_embeddings: torch.Tensor
-
-
-@dataclass
-class TextSearchModel:
-    bi_encoder: BaseEncoder
-    cross_encoder: Optional[CrossEncoder] = None
-    top_k: Optional[int] = 15
-
-
-@dataclass
-class ImageSearchModel:
-    image_encoder: BaseEncoder
-
-
-@dataclass
-class SearchModels:
-    text_search: Optional[TextSearchModel] = None
-
-
-@dataclass
-class OfflineChatProcessorConfig:
-    loaded_model: Union[Any, None] = None
-
-
-class OfflineChatProcessorModel:
-    def __init__(self, chat_model: str = "bartowski/Meta-Llama-3.1-8B-Instruct-GGUF", max_tokens: int = None):
-        self.chat_model = chat_model
-        self.loaded_model = None
-        try:
-            self.loaded_model = download_model(self.chat_model, max_tokens=max_tokens)
-        except ValueError as e:
-            self.loaded_model = None
-            logger.error(f"Error while loading offline chat model: {e}", exc_info=True)
-            raise e

khoj/utils/constants.py

@@ -10,13 +10,6 @@ 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_models = [
-    "bartowski/Meta-Llama-3.1-8B-Instruct-GGUF",
-    "bartowski/Llama-3.2-3B-Instruct-GGUF",
-    "bartowski/gemma-2-9b-it-GGUF",
-    "bartowski/gemma-2-2b-it-GGUF",
-    "bartowski/Qwen2.5-14B-Instruct-GGUF",
-]
 default_openai_chat_models = ["gpt-4o-mini", "gpt-4.1", "o3", "o4-mini"]
 default_gemini_chat_models = ["gemini-2.0-flash", "gemini-2.5-flash-preview-05-20", "gemini-2.5-pro-preview-06-05"]
 default_anthropic_chat_models = ["claude-sonnet-4-0", "claude-3-5-haiku-latest"]

khoj/utils/helpers.py

@@ -47,7 +47,6 @@ if TYPE_CHECKING:
     from sentence_transformers import CrossEncoder, SentenceTransformer
 
     from khoj.utils.models import BaseEncoder
-    from khoj.utils.rawconfig import AppConfig
 
 logger = logging.getLogger(__name__)
 
@@ -267,23 +266,16 @@ def get_server_id():
     return server_id
 
 
-def telemetry_disabled(app_config: AppConfig, telemetry_disable_env) -> bool:
-    if telemetry_disable_env is True:
-        return True
-    return not app_config or not app_config.should_log_telemetry
-
-
 def log_telemetry(
     telemetry_type: str,
     api: str = None,
     client: Optional[str] = None,
-    app_config: Optional[AppConfig] = None,
     disable_telemetry_env: bool = False,
     properties: dict = None,
 ):
     """Log basic app usage telemetry like client, os, api called"""
     # Do not log usage telemetry, if telemetry is disabled via app config
-    if telemetry_disabled(app_config, disable_telemetry_env):
+    if disable_telemetry_env:
         return []
 
     if properties.get("server_id") is None: