khoj 1.31.0__py3-none-any.whl → 1.31.1.dev62__py3-none-any.whl

khoj/processor/conversation/anthropic/anthropic_chat.py

@@ -5,7 +5,7 @@ from typing import Dict, List, Optional
 import pyjson5
 from langchain.schema import ChatMessage
 
-from khoj.database.models import Agent, ChatModelOptions, KhojUser
+from khoj.database.models import Agent, ChatModel, KhojUser
 from khoj.processor.conversation import prompts
 from khoj.processor.conversation.anthropic.utils import (
     anthropic_chat_completion_with_backoff,
@@ -85,7 +85,7 @@ def extract_questions_anthropic(
     prompt = construct_structured_message(
         message=prompt,
         images=query_images,
-        model_type=ChatModelOptions.ModelType.ANTHROPIC,
+        model_type=ChatModel.ModelType.ANTHROPIC,
         vision_enabled=vision_enabled,
         attached_file_context=query_files,
     )
@@ -218,7 +218,7 @@ def converse_anthropic(
         tokenizer_name=tokenizer_name,
         query_images=query_images,
         vision_enabled=vision_available,
-        model_type=ChatModelOptions.ModelType.ANTHROPIC,
+        model_type=ChatModel.ModelType.ANTHROPIC,
         query_files=query_files,
         generated_files=generated_files,
         generated_asset_results=generated_asset_results,

khoj/processor/conversation/google/gemini_chat.py

@@ -5,7 +5,7 @@ from typing import Dict, List, Optional
 import pyjson5
 from langchain.schema import ChatMessage
 
-from khoj.database.models import Agent, ChatModelOptions, KhojUser
+from khoj.database.models import Agent, ChatModel, KhojUser
 from khoj.processor.conversation import prompts
 from khoj.processor.conversation.google.utils import (
     format_messages_for_gemini,
@@ -86,7 +86,7 @@ def extract_questions_gemini(
     prompt = construct_structured_message(
         message=prompt,
         images=query_images,
-        model_type=ChatModelOptions.ModelType.GOOGLE,
+        model_type=ChatModel.ModelType.GOOGLE,
         vision_enabled=vision_enabled,
         attached_file_context=query_files,
     )
@@ -229,7 +229,7 @@ def converse_gemini(
         tokenizer_name=tokenizer_name,
         query_images=query_images,
         vision_enabled=vision_available,
-        model_type=ChatModelOptions.ModelType.GOOGLE,
+        model_type=ChatModel.ModelType.GOOGLE,
         query_files=query_files,
         generated_files=generated_files,
         generated_asset_results=generated_asset_results,

khoj/processor/conversation/offline/chat_model.py

@@ -9,7 +9,7 @@ import pyjson5
 from langchain.schema import ChatMessage
 from llama_cpp import Llama
 
-from khoj.database.models import Agent, ChatModelOptions, KhojUser
+from khoj.database.models import Agent, ChatModel, KhojUser
 from khoj.processor.conversation import prompts
 from khoj.processor.conversation.offline.utils import download_model
 from khoj.processor.conversation.utils import (
@@ -96,7 +96,7 @@ def extract_questions_offline(
         model_name=model,
         loaded_model=offline_chat_model,
         max_prompt_size=max_prompt_size,
-        model_type=ChatModelOptions.ModelType.OFFLINE,
+        model_type=ChatModel.ModelType.OFFLINE,
         query_files=query_files,
     )
 
@@ -105,7 +105,7 @@ def extract_questions_offline(
         response = send_message_to_model_offline(
             messages,
             loaded_model=offline_chat_model,
-            model=model,
+            model_name=model,
             max_prompt_size=max_prompt_size,
             temperature=temperature,
             response_type="json_object",
@@ -154,7 +154,7 @@ def converse_offline(
     online_results={},
     code_results={},
     conversation_log={},
-    model: str = "bartowski/Meta-Llama-3.1-8B-Instruct-GGUF",
+    model_name: str = "bartowski/Meta-Llama-3.1-8B-Instruct-GGUF",
     loaded_model: Union[Any, None] = None,
     completion_func=None,
     conversation_commands=[ConversationCommand.Default],
@@ -174,8 +174,8 @@ def converse_offline(
     """
     # Initialize Variables
     assert loaded_model is None or isinstance(loaded_model, Llama), "loaded_model must be of type Llama, if configured"
-    offline_chat_model = loaded_model or download_model(model, max_tokens=max_prompt_size)
-    tracer["chat_model"] = model
+    offline_chat_model = loaded_model or download_model(model_name, max_tokens=max_prompt_size)
+    tracer["chat_model"] = model_name
     current_date = datetime.now()
 
     if agent and agent.personality:
@@ -228,18 +228,18 @@ def converse_offline(
         system_prompt,
         conversation_log,
         context_message=context_message,
-        model_name=model,
+        model_name=model_name,
         loaded_model=offline_chat_model,
         max_prompt_size=max_prompt_size,
         tokenizer_name=tokenizer_name,
-        model_type=ChatModelOptions.ModelType.OFFLINE,
+        model_type=ChatModel.ModelType.OFFLINE,
         query_files=query_files,
         generated_files=generated_files,
         generated_asset_results=generated_asset_results,
         program_execution_context=additional_context,
     )
 
-    logger.debug(f"Conversation Context for {model}: {messages_to_print(messages)}")
+    logger.debug(f"Conversation Context for {model_name}: {messages_to_print(messages)}")
 
     g = ThreadedGenerator(references, online_results, completion_func=completion_func)
     t = Thread(target=llm_thread, args=(g, messages, offline_chat_model, max_prompt_size, tracer))
@@ -273,7 +273,7 @@ def llm_thread(g, messages: List[ChatMessage], model: Any, max_prompt_size: int
 def send_message_to_model_offline(
     messages: List[ChatMessage],
     loaded_model=None,
-    model="bartowski/Meta-Llama-3.1-8B-Instruct-GGUF",
+    model_name="bartowski/Meta-Llama-3.1-8B-Instruct-GGUF",
     temperature: float = 0.2,
     streaming=False,
     stop=[],
@@ -282,7 +282,7 @@ def send_message_to_model_offline(
     tracer: dict = {},
 ):
     assert loaded_model is None or isinstance(loaded_model, Llama), "loaded_model must be of type Llama, if configured"
-    offline_chat_model = loaded_model or download_model(model, max_tokens=max_prompt_size)
+    offline_chat_model = loaded_model or download_model(model_name, max_tokens=max_prompt_size)
     messages_dict = [{"role": message.role, "content": message.content} for message in messages]
     seed = int(os.getenv("KHOJ_LLM_SEED")) if os.getenv("KHOJ_LLM_SEED") else None
     response = offline_chat_model.create_chat_completion(
@@ -301,7 +301,7 @@ def send_message_to_model_offline(
 
     # Save conversation trace for non-streaming responses
     # Streamed responses need to be saved by the calling function
-    tracer["chat_model"] = model
+    tracer["chat_model"] = model_name
     tracer["temperature"] = temperature
     if is_promptrace_enabled():
         commit_conversation_trace(messages, response_text, tracer)

khoj/processor/conversation/openai/gpt.py

@@ -5,7 +5,7 @@ from typing import Dict, List, Optional
 import pyjson5
 from langchain.schema import ChatMessage
 
-from khoj.database.models import Agent, ChatModelOptions, KhojUser
+from khoj.database.models import Agent, ChatModel, KhojUser
 from khoj.processor.conversation import prompts
 from khoj.processor.conversation.openai.utils import (
     chat_completion_with_backoff,
@@ -83,7 +83,7 @@ def extract_questions(
     prompt = construct_structured_message(
         message=prompt,
         images=query_images,
-        model_type=ChatModelOptions.ModelType.OPENAI,
+        model_type=ChatModel.ModelType.OPENAI,
         vision_enabled=vision_enabled,
         attached_file_context=query_files,
     )
@@ -128,7 +128,7 @@ def send_message_to_model(
     # Get Response from GPT
     return completion_with_backoff(
         messages=messages,
-        model=model,
+        model_name=model,
         openai_api_key=api_key,
         temperature=temperature,
         api_base_url=api_base_url,
@@ -220,7 +220,7 @@ def converse_openai(
         tokenizer_name=tokenizer_name,
         query_images=query_images,
         vision_enabled=vision_available,
-        model_type=ChatModelOptions.ModelType.OPENAI,
+        model_type=ChatModel.ModelType.OPENAI,
         query_files=query_files,
         generated_files=generated_files,
         generated_asset_results=generated_asset_results,

khoj/processor/conversation/openai/utils.py

@@ -40,7 +40,13 @@ openai_clients: Dict[str, openai.OpenAI] = {}
     reraise=True,
 )
 def completion_with_backoff(
-    messages, model, temperature=0, openai_api_key=None, api_base_url=None, model_kwargs=None, tracer: dict = {}
+    messages,
+    model_name: str,
+    temperature=0,
+    openai_api_key=None,
+    api_base_url=None,
+    model_kwargs: dict = {},
+    tracer: dict = {},
 ) -> str:
     client_key = f"{openai_api_key}--{api_base_url}"
     client: openai.OpenAI | None = openai_clients.get(client_key)
@@ -56,7 +62,7 @@ def completion_with_backoff(
 
     # Update request parameters for compatability with o1 model series
     # Refer: https://platform.openai.com/docs/guides/reasoning/beta-limitations
-    if model.startswith("o1"):
+    if model_name.startswith("o1"):
         temperature = 1
         model_kwargs.pop("stop", None)
         model_kwargs.pop("response_format", None)
@@ -66,12 +72,12 @@ def completion_with_backoff(
 
     chat: ChatCompletion | openai.Stream[ChatCompletionChunk] = client.chat.completions.create(
         messages=formatted_messages,  # type: ignore
-        model=model,  # type: ignore
+        model=model_name,  # type: ignore
         stream=stream,
         stream_options={"include_usage": True} if stream else {},
         temperature=temperature,
         timeout=20,
-        **(model_kwargs or dict()),
+        **model_kwargs,
     )
 
     aggregated_response = ""
@@ -91,10 +97,11 @@ def completion_with_backoff(
     # Calculate cost of chat
     input_tokens = chunk.usage.prompt_tokens if hasattr(chunk, "usage") and chunk.usage else 0
     output_tokens = chunk.usage.completion_tokens if hasattr(chunk, "usage") and chunk.usage else 0
-    tracer["usage"] = get_chat_usage_metrics(model, input_tokens, output_tokens, tracer.get("usage"))
+    cost = chunk.usage.model_extra.get("estimated_cost") or 0  # Estimated costs returned by DeepInfra API
+    tracer["usage"] = get_chat_usage_metrics(model_name, input_tokens, output_tokens, tracer.get("usage"), cost)
 
     # Save conversation trace
-    tracer["chat_model"] = model
+    tracer["chat_model"] = model_name
     tracer["temperature"] = temperature
     if is_promptrace_enabled():
         commit_conversation_trace(messages, aggregated_response, tracer)
@@ -139,11 +146,11 @@ def chat_completion_with_backoff(
 def llm_thread(
     g,
     messages,
-    model_name,
+    model_name: str,
     temperature,
     openai_api_key=None,
     api_base_url=None,
-    model_kwargs=None,
+    model_kwargs: dict = {},
     tracer: dict = {},
 ):
     try:
@@ -177,7 +184,7 @@ def llm_thread(
             stream_options={"include_usage": True} if stream else {},
             temperature=temperature,
             timeout=20,
-            **(model_kwargs or dict()),
+            **model_kwargs,
         )
 
         aggregated_response = ""
@@ -202,7 +209,8 @@ def llm_thread(
         # Calculate cost of chat
         input_tokens = chunk.usage.prompt_tokens if hasattr(chunk, "usage") and chunk.usage else 0
         output_tokens = chunk.usage.completion_tokens if hasattr(chunk, "usage") and chunk.usage else 0
-        tracer["usage"] = get_chat_usage_metrics(model_name, input_tokens, output_tokens, tracer.get("usage"))
+        cost = chunk.usage.model_extra.get("estimated_cost") or 0  # Estimated costs returned by DeepInfra API
+        tracer["usage"] = get_chat_usage_metrics(model_name, input_tokens, output_tokens, tracer.get("usage"), cost)
 
         # Save conversation trace
         tracer["chat_model"] = model_name

khoj/processor/conversation/utils.py

@@ -24,7 +24,7 @@ from llama_cpp.llama import Llama
 from transformers import AutoTokenizer
 
 from khoj.database.adapters import ConversationAdapters
-from khoj.database.models import ChatModelOptions, ClientApplication, KhojUser
+from khoj.database.models import ChatModel, ClientApplication, KhojUser
 from khoj.processor.conversation import prompts
 from khoj.processor.conversation.offline.utils import download_model, infer_max_tokens
 from khoj.search_filter.base_filter import BaseFilter
@@ -330,9 +330,9 @@ def construct_structured_message(
     Format messages into appropriate multimedia format for supported chat model types
     """
     if model_type in [
-        ChatModelOptions.ModelType.OPENAI,
-        ChatModelOptions.ModelType.GOOGLE,
-        ChatModelOptions.ModelType.ANTHROPIC,
+        ChatModel.ModelType.OPENAI,
+        ChatModel.ModelType.GOOGLE,
+        ChatModel.ModelType.ANTHROPIC,
     ]:
         if not attached_file_context and not (vision_enabled and images):
             return message

khoj/processor/tools/online_search.py

@@ -102,8 +102,14 @@ async def search_online(
         async for event in send_status_func(f"**Searching the Internet for**: {subqueries_str}"):
             yield {ChatEvent.STATUS: event}
 
+    if SERPER_DEV_API_KEY:
+        search_func = search_with_serper
+    elif JINA_API_KEY:
+        search_func = search_with_jina
+    else:
+        search_func = search_with_searxng
+
     with timer(f"Internet searches for {subqueries} took", logger):
-        search_func = search_with_google if SERPER_DEV_API_KEY else search_with_jina
         search_tasks = [search_func(subquery, location) for subquery in subqueries]
         search_results = await asyncio.gather(*search_tasks)
         response_dict = {subquery: search_result for subquery, search_result in search_results}
@@ -148,7 +154,48 @@ async def search_online(
     yield response_dict
 
 
-async def search_with_google(query: str, location: LocationData) -> Tuple[str, Dict[str, List[Dict]]]:
+async def search_with_searxng(query: str, location: LocationData) -> Tuple[str, Dict[str, List[Dict]]]:
+    """Search using local SearXNG instance."""
+    # Use environment variable or default to localhost
+    searxng_url = os.getenv("KHOJ_SEARXNG_URL", "http://localhost:42113")
+    search_url = f"{searxng_url}/search"
+    country_code = location.country_code.lower() if location and location.country_code else "us"
+
+    params = {"q": query, "format": "html", "language": "en", "country": country_code, "categories": "general"}
+
+    async with aiohttp.ClientSession() as session:
+        try:
+            async with session.get(search_url, params=params) as response:
+                if response.status != 200:
+                    logger.error(f"SearXNG search failed to call {searxng_url}: {await response.text()}")
+                    return query, {}
+
+                html_content = await response.text()
+
+                soup = BeautifulSoup(html_content, "html.parser")
+                organic_results = []
+
+                for result in soup.find_all("article", class_="result"):
+                    title_elem = result.find("a", rel="noreferrer")
+                    if title_elem:
+                        title = title_elem.text.strip()
+                        link = title_elem["href"]
+
+                        description_elem = result.find("p", class_="content")
+                        description = description_elem.text.strip() if description_elem else None
+
+                        organic_results.append({"title": title, "link": link, "description": description})
+
+                extracted_search_result = {"organic": organic_results}
+
+                return query, extracted_search_result
+
+        except Exception as e:
+            logger.error(f"Error searching with SearXNG: {str(e)}")
+            return query, {}
+
+
+async def search_with_serper(query: str, location: LocationData) -> Tuple[str, Dict[str, List[Dict]]]:
     country_code = location.country_code.lower() if location and location.country_code else "us"
     payload = json.dumps({"q": query, "gl": country_code})
     headers = {"X-API-KEY": SERPER_DEV_API_KEY, "Content-Type": "application/json"}

khoj/routers/api.py

@@ -28,12 +28,7 @@ from khoj.database.adapters import (
     get_default_search_model,
     get_user_photo,
 )
-from khoj.database.models import (
-    Agent,
-    ChatModelOptions,
-    KhojUser,
-    SpeechToTextModelOptions,
-)
+from khoj.database.models import Agent, ChatModel, KhojUser, SpeechToTextModelOptions
 from khoj.processor.conversation import prompts
 from khoj.processor.conversation.anthropic.anthropic_chat import (
     extract_questions_anthropic,
@@ -404,15 +399,15 @@ async def extract_references_and_questions(
     # Infer search queries from user message
     with timer("Extracting search queries took", logger):
         # If we've reached here, either the user has enabled offline chat or the openai model is enabled.
-        conversation_config = await ConversationAdapters.aget_default_conversation_config(user)
-        vision_enabled = conversation_config.vision_enabled
+        chat_model = await ConversationAdapters.aget_default_chat_model(user)
+        vision_enabled = chat_model.vision_enabled
 
-        if conversation_config.model_type == ChatModelOptions.ModelType.OFFLINE:
+        if chat_model.model_type == ChatModel.ModelType.OFFLINE:
             using_offline_chat = True
-            chat_model = conversation_config.chat_model
-            max_tokens = conversation_config.max_prompt_size
+            chat_model_name = chat_model.name
+            max_tokens = chat_model.max_prompt_size
             if state.offline_chat_processor_config is None:
-                state.offline_chat_processor_config = OfflineChatProcessorModel(chat_model, max_tokens)
+                state.offline_chat_processor_config = OfflineChatProcessorModel(chat_model_name, max_tokens)
 
             loaded_model = state.offline_chat_processor_config.loaded_model
 
@@ -424,18 +419,18 @@ async def extract_references_and_questions(
                 should_extract_questions=True,
                 location_data=location_data,
                 user=user,
-                max_prompt_size=conversation_config.max_prompt_size,
+                max_prompt_size=chat_model.max_prompt_size,
                 personality_context=personality_context,
                 query_files=query_files,
                 tracer=tracer,
             )
-        elif conversation_config.model_type == ChatModelOptions.ModelType.OPENAI:
-            api_key = conversation_config.ai_model_api.api_key
-            base_url = conversation_config.ai_model_api.api_base_url
-            chat_model = conversation_config.chat_model
+        elif chat_model.model_type == ChatModel.ModelType.OPENAI:
+            api_key = chat_model.ai_model_api.api_key
+            base_url = chat_model.ai_model_api.api_base_url
+            chat_model_name = chat_model.name
             inferred_queries = extract_questions(
                 defiltered_query,
-                model=chat_model,
+                model=chat_model_name,
                 api_key=api_key,
                 api_base_url=base_url,
                 conversation_log=meta_log,
@@ -447,13 +442,13 @@ async def extract_references_and_questions(
                 query_files=query_files,
                 tracer=tracer,
             )
-        elif conversation_config.model_type == ChatModelOptions.ModelType.ANTHROPIC:
-            api_key = conversation_config.ai_model_api.api_key
-            chat_model = conversation_config.chat_model
+        elif chat_model.model_type == ChatModel.ModelType.ANTHROPIC:
+            api_key = chat_model.ai_model_api.api_key
+            chat_model_name = chat_model.name
             inferred_queries = extract_questions_anthropic(
                 defiltered_query,
                 query_images=query_images,
-                model=chat_model,
+                model=chat_model_name,
                 api_key=api_key,
                 conversation_log=meta_log,
                 location_data=location_data,
@@ -463,17 +458,17 @@ async def extract_references_and_questions(
                 query_files=query_files,
                 tracer=tracer,
             )
-        elif conversation_config.model_type == ChatModelOptions.ModelType.GOOGLE:
-            api_key = conversation_config.ai_model_api.api_key
-            chat_model = conversation_config.chat_model
+        elif chat_model.model_type == ChatModel.ModelType.GOOGLE:
+            api_key = chat_model.ai_model_api.api_key
+            chat_model_name = chat_model.name
             inferred_queries = extract_questions_gemini(
                 defiltered_query,
                 query_images=query_images,
-                model=chat_model,
+                model=chat_model_name,
                 api_key=api_key,
                 conversation_log=meta_log,
                 location_data=location_data,
-                max_tokens=conversation_config.max_prompt_size,
+                max_tokens=chat_model.max_prompt_size,
                 user=user,
                 vision_enabled=vision_enabled,
                 personality_context=personality_context,

khoj/routers/api_agents.py

@@ -62,7 +62,7 @@ async def all_agents(
             "color": agent.style_color,
             "icon": agent.style_icon,
             "privacy_level": agent.privacy_level,
-            "chat_model": agent.chat_model.chat_model,
+            "chat_model": agent.chat_model.name,
             "files": file_names,
             "input_tools": agent.input_tools,
             "output_modes": agent.output_modes,
@@ -150,7 +150,7 @@ async def get_agent(
         "color": agent.style_color,
         "icon": agent.style_icon,
         "privacy_level": agent.privacy_level,
-        "chat_model": agent.chat_model.chat_model,
+        "chat_model": agent.chat_model.name,
         "files": file_names,
         "input_tools": agent.input_tools,
         "output_modes": agent.output_modes,
@@ -225,7 +225,7 @@ async def create_agent(
         "color": agent.style_color,
         "icon": agent.style_icon,
         "privacy_level": agent.privacy_level,
-        "chat_model": agent.chat_model.chat_model,
+        "chat_model": agent.chat_model.name,
         "files": body.files,
         "input_tools": agent.input_tools,
         "output_modes": agent.output_modes,
@@ -286,7 +286,7 @@ async def update_agent(
         "color": agent.style_color,
         "icon": agent.style_icon,
         "privacy_level": agent.privacy_level,
-        "chat_model": agent.chat_model.chat_model,
+        "chat_model": agent.chat_model.name,
         "files": body.files,
         "input_tools": agent.input_tools,
         "output_modes": agent.output_modes,

khoj/routers/api_chat.py

@@ -58,7 +58,7 @@ from khoj.routers.helpers import (
     is_ready_to_chat,
     read_chat_stream,
     update_telemetry_state,
-    validate_conversation_config,
+    validate_chat_model,
 )
 from khoj.routers.research import (
     InformationCollectionIteration,
@@ -205,7 +205,7 @@ def chat_history(
     n: Optional[int] = None,
 ):
     user = request.user.object
-    validate_conversation_config(user)
+    validate_chat_model(user)
 
     # Load Conversation History
     conversation = ConversationAdapters.get_conversation_by_user(
@@ -724,7 +724,16 @@ async def chat(
                 yield result
             return
 
-        conversation_commands = [get_conversation_command(query=q, any_references=True)]
+        # Automated tasks are handled before to allow mixing them with other conversation commands
+        cmds_to_rate_limit = []
+        is_automated_task = False
+        if q.startswith("/automated_task"):
+            is_automated_task = True
+            q = q.replace("/automated_task", "").lstrip()
+            cmds_to_rate_limit += [ConversationCommand.AutomatedTask]
+
+        # Extract conversation command from query
+        conversation_commands = [get_conversation_command(query=q)]
 
         conversation = await ConversationAdapters.aget_conversation_by_user(
             user,
@@ -757,11 +766,8 @@ async def chat(
         location = None
         if city or region or country or country_code:
             location = LocationData(city=city, region=region, country=country, country_code=country_code)
-
         user_message_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-
         meta_log = conversation.conversation_log
-        is_automated_task = conversation_commands == [ConversationCommand.AutomatedTask]
 
         researched_results = ""
         online_results: Dict = dict()
@@ -778,7 +784,7 @@ async def chat(
         generated_excalidraw_diagram: str = None
         program_execution_context: List[str] = []
 
-        if conversation_commands == [ConversationCommand.Default] or is_automated_task:
+        if conversation_commands == [ConversationCommand.Default]:
             chosen_io = await aget_data_sources_and_output_format(
                 q,
                 meta_log,
@@ -799,7 +805,8 @@ async def chat(
             async for result in send_event(ChatEvent.STATUS, f"**Selected Tools:** {conversation_commands_str}"):
                 yield result
 
-        for cmd in conversation_commands:
+        cmds_to_rate_limit += conversation_commands
+        for cmd in cmds_to_rate_limit:
             try:
                 await conversation_command_rate_limiter.update_and_check_if_valid(request, cmd)
                 q = q.replace(f"/{cmd.value}", "").strip()
@@ -898,10 +905,10 @@ async def chat(
         custom_filters = []
         if conversation_commands == [ConversationCommand.Help]:
             if not q:
-                conversation_config = await ConversationAdapters.aget_user_conversation_config(user)
-                if conversation_config == None:
-                    conversation_config = await ConversationAdapters.aget_default_conversation_config(user)
-                model_type = conversation_config.model_type
+                chat_model = await ConversationAdapters.aget_user_chat_model(user)
+                if chat_model == None:
+                    chat_model = await ConversationAdapters.aget_default_chat_model(user)
+                model_type = chat_model.model_type
                 formatted_help = help_message.format(model=model_type, version=state.khoj_version, device=get_device())
                 async for result in send_llm_response(formatted_help, tracer.get("usage")):
                     yield result

khoj/routers/api_model.py

@@ -24,7 +24,7 @@ def get_chat_model_options(
 
     all_conversation_options = list()
     for conversation_option in conversation_options:
-        all_conversation_options.append({"chat_model": conversation_option.chat_model, "id": conversation_option.id})
+        all_conversation_options.append({"chat_model": conversation_option.name, "id": conversation_option.id})
 
     return Response(content=json.dumps(all_conversation_options), media_type="application/json", status_code=200)
 
@@ -37,12 +37,12 @@ def get_user_chat_model(
 ):
     user = request.user.object
 
-    chat_model = ConversationAdapters.get_conversation_config(user)
+    chat_model = ConversationAdapters.get_chat_model(user)
 
     if chat_model is None:
-        chat_model = ConversationAdapters.get_default_conversation_config(user)
+        chat_model = ConversationAdapters.get_default_chat_model(user)
 
-    return Response(status_code=200, content=json.dumps({"id": chat_model.id, "chat_model": chat_model.chat_model}))
+    return Response(status_code=200, content=json.dumps({"id": chat_model.id, "chat_model": chat_model.name}))
 
 
 @api_model.post("/chat", status_code=200)