khoj 1.30.11.dev64__py3-none-any.whl → 1.32.3.dev34__py3-none-any.whl

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

@@ -23,6 +23,7 @@ from khoj.database.adapters import (
     aget_user_name,
 )
 from khoj.database.models import Agent, KhojUser
+from khoj.processor.conversation import prompts
 from khoj.processor.conversation.prompts import help_message, no_entries_found
 from khoj.processor.conversation.utils import defilter_query, save_to_conversation_log
 from khoj.processor.image.generate import text_to_image
@@ -57,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,
@@ -204,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(
@@ -723,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,
@@ -756,15 +766,13 @@ 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()
         code_results: Dict = dict()
+        generated_asset_results: Dict = dict()
         ## Extract Document References
         compiled_references: List[Any] = []
         inferred_queries: List[Any] = []
@@ -776,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,
@@ -797,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()
@@ -896,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
@@ -1128,6 +1137,10 @@ async def chat(
             else:
                 generated_images.append(generated_image)
 
+                generated_asset_results["images"] = {
+                    "query": improved_image_prompt,
+                }
+
                 async for result in send_event(
                     ChatEvent.GENERATED_ASSETS,
                     {
@@ -1166,6 +1179,10 @@ async def chat(
 
                         generated_excalidraw_diagram = diagram_description
 
+                        generated_asset_results["diagrams"] = {
+                            "query": better_diagram_description_prompt,
+                        }
+
                         async for result in send_event(
                             ChatEvent.GENERATED_ASSETS,
                             {
@@ -1176,7 +1193,9 @@ async def chat(
                     else:
                         error_message = "Failed to generate diagram. Please try again later."
                         program_execution_context.append(
-                            f"AI attempted to programmatically generate a diagram but failed due to a program issue. Generally, it is able to do so, but encountered a system issue this time. AI can suggest text description or rendering of the diagram or user can try again with a simpler prompt."
+                            prompts.failed_diagram_generation.format(
+                                attempted_diagram=better_diagram_description_prompt
+                            )
                         )
 
                         async for result in send_event(ChatEvent.STATUS, error_message):
@@ -1209,6 +1228,7 @@ async def chat(
             generated_files,
             generated_excalidraw_diagram,
             program_execution_context,
+            generated_asset_results,
             tracer,
         )
 

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)

khoj/routers/auth.py

@@ -4,7 +4,8 @@ import logging
 import os
 from typing import Optional
 
-from fastapi import APIRouter
+import requests
+from fastapi import APIRouter, Depends
 from pydantic import BaseModel, EmailStr
 from starlette.authentication import requires
 from starlette.config import Config
@@ -21,8 +22,13 @@ from khoj.database.adapters import (
     get_or_create_user,
 )
 from khoj.routers.email import send_magic_link_email, send_welcome_email
-from khoj.routers.helpers import get_next_url, update_telemetry_state
+from khoj.routers.helpers import (
+    EmailVerificationApiRateLimiter,
+    get_next_url,
+    update_telemetry_state,
+)
 from khoj.utils import state
+from khoj.utils.helpers import in_debug_mode
 
 logger = logging.getLogger(__name__)
 
@@ -98,16 +104,28 @@ async def login_magic_link(request: Request, form: MagicLinkForm):
 
 
 @auth_router.get("/magic")
-async def sign_in_with_magic_link(request: Request, code: str):
-    user = await aget_user_validated_by_email_verification_code(code)
+async def sign_in_with_magic_link(
+    request: Request,
+    code: str,
+    email: str,
+    rate_limiter=Depends(
+        EmailVerificationApiRateLimiter(requests=10, window=60 * 60 * 24, slug="magic_link_verification")
+    ),
+):
+    user, code_is_expired = await aget_user_validated_by_email_verification_code(code, email)
+
     if user:
+        if code_is_expired:
+            request.session["user"] = {}
+            return Response(status_code=403)
+
         id_info = {
             "email": user.email,
         }
 
         request.session["user"] = dict(id_info)
         return RedirectResponse(url="/")
-    return RedirectResponse(request.app.url_path_for("login_page"))
+    return Response(status_code=401)
 
 
 @auth_router.post("/token")
@@ -140,11 +158,12 @@ async def delete_token(request: Request, token: str):
 
 
 @auth_router.post("/redirect")
-async def auth(request: Request):
+async def auth_post(request: Request):
+    # This is maintained for compatibility with the /login endpoint
     form = await request.form()
     next_url = get_next_url(request)
     for q in request.query_params:
-        if not q == "next":
+        if q != "next":
             next_url += f"&{q}={request.query_params[q]}"
 
     credential = form.get("credential")
@@ -183,7 +202,89 @@ async def auth(request: Request):
     return RedirectResponse(url=next_url, status_code=HTTP_302_FOUND)
 
 
+@auth_router.get("/redirect")
+async def auth(request: Request):
+    next_url = get_next_url(request)
+    for q in request.query_params:
+        if q in ["code", "state", "scope", "authuser", "prompt", "session_state", "access_type"]:
+            continue
+        if q != "next":
+            next_url += f"&{q}={request.query_params[q]}"
+
+    code = request.query_params.get("code")
+
+    # 1. Construct the full redirect URI including domain
+    base_url = str(request.base_url).rstrip("/")
+
+    if not in_debug_mode():
+        base_url = base_url.replace("http://", "https://")
+
+    redirect_uri = f"{base_url}{request.app.url_path_for('auth')}"
+
+    payload = {
+        "code": code,
+        "client_id": os.environ["GOOGLE_CLIENT_ID"],
+        "client_secret": os.environ["GOOGLE_CLIENT_SECRET"],
+        "redirect_uri": redirect_uri,
+        "grant_type": "authorization_code",
+    }
+
+    verified_data = requests.post(
+        "https://oauth2.googleapis.com/token",
+        headers={"Content-Type": "application/x-www-form-urlencoded"},
+        data=payload,
+    )
+
+    if verified_data.status_code != 200:
+        logger.error(f"Token request failed: {verified_data.text}")
+        try:
+            error_json = verified_data.json()
+            logger.error(f"Error response JSON for Google verification: {error_json}")
+        except ValueError:
+            logger.error("Response content is not valid JSON")
+        verified_data.raise_for_status()
+
+    credential = verified_data.json().get("id_token")
+
+    if not credential:
+        logger.error("Missing id_token in OAuth response")
+        return RedirectResponse(url="/login?error=invalid_token", status_code=HTTP_302_FOUND)
+
+    try:
+        idinfo = id_token.verify_oauth2_token(credential, google_requests.Request(), os.environ["GOOGLE_CLIENT_ID"])
+    except OAuthError as error:
+        return HTMLResponse(f"<h1>{error.error}</h1>")
+    khoj_user = await get_or_create_user(idinfo)
+
+    if khoj_user:
+        request.session["user"] = dict(idinfo)
+
+        if datetime.timedelta(minutes=3) > (datetime.datetime.now(datetime.timezone.utc) - khoj_user.date_joined):
+            asyncio.create_task(send_welcome_email(idinfo["name"], idinfo["email"]))
+            update_telemetry_state(
+                request=request,
+                telemetry_type="api",
+                api="create_user__google",
+                metadata={"server_id": str(khoj_user.uuid)},
+            )
+            logger.log(logging.INFO, f"🥳 New User Created: {khoj_user.uuid}")
+
+    return RedirectResponse(url=next_url, status_code=HTTP_302_FOUND)
+
+
 @auth_router.get("/logout")
 async def logout(request: Request):
     request.session.pop("user", None)
     return RedirectResponse(url="/")
+
+
+@auth_router.get("/oauth/metadata")
+async def oauth_metadata(request: Request):
+    redirect_uri = str(request.app.url_path_for("auth"))
+
+    return {
+        "google": {
+            "client_id": os.environ.get("GOOGLE_CLIENT_ID"),
+            "redirect_uri": f"{redirect_uri}",
+        }
+    }

khoj/routers/email.py

@@ -1,12 +1,8 @@
 import logging
 import os
 
-try:
-    import resend
-except ImportError:
-    pass
-
 import markdown_it
+import resend
 from django.conf import settings
 from jinja2 import Environment, FileSystemLoader
 
@@ -23,7 +19,7 @@ static_files = os.path.join(settings.BASE_DIR, "static")
 env = Environment(loader=FileSystemLoader(static_files))
 
 if not RESEND_API_KEY:
-    logger.warn("RESEND_API_KEY not set - email sending disabled")
+    logger.warning("RESEND_API_KEY not set - email sending disabled")
 else:
     resend.api_key = RESEND_API_KEY
 
@@ -33,7 +29,7 @@ def is_resend_enabled():
 
 
 async def send_magic_link_email(email, unique_id, host):
-    sign_in_link = f"{host}auth/magic?code={unique_id}"
+    sign_in_link = f"{host}auth/magic?code={unique_id}&email={email}"
 
     if not is_resend_enabled():
         logger.debug(f"Email sending disabled. Share this sign-in link with the user: {sign_in_link}")
@@ -41,13 +37,13 @@ async def send_magic_link_email(email, unique_id, host):
 
     template = env.get_template("magic_link.html")
 
-    html_content = template.render(link=f"{host}auth/magic?code={unique_id}")
+    html_content = template.render(link=f"{host}auth/magic?code={unique_id}", code=unique_id)
 
     resend.Emails.send(
         {
             "sender": os.environ.get("RESEND_EMAIL", "noreply@khoj.dev"),
             "to": email,
-            "subject": "Your Sign-In Link for Khoj 🚀",
+            "subject": f"Your login code to Khoj",
             "html": html_content,
         }
     )
@@ -64,7 +60,7 @@ async def send_welcome_email(name, email):
 
     resend.Emails.send(
         {
-            "sender": "team@khoj.dev",
+            "sender": os.environ.get("RESEND_EMAIL", "team@khoj.dev"),
             "to": email,
             "subject": f"{name}, four ways to use Khoj" if name else "Four ways to use Khoj",
             "html": html_content,
@@ -92,7 +88,7 @@ async def send_query_feedback(uquery, kquery, sentiment, user_email):
 
     logger.info(f"Sending feedback email for query {uquery}")
 
-    # rendering feedback email using feedback.html as template
+    # render feedback email using feedback.html as template
     template = env.get_template("feedback.html")
     html_content = template.render(
         uquery=uquery if not is_none_or_empty(uquery) else "N/A",
@@ -100,10 +96,10 @@ async def send_query_feedback(uquery, kquery, sentiment, user_email):
         sentiment=sentiment if not is_none_or_empty(sentiment) else "N/A",
         user_email=user_email if not is_none_or_empty(user_email) else "N/A",
     )
-    # send feedback from two fixed accounts
+    # send feedback to fixed account
     r = resend.Emails.send(
         {
-            "sender": "saba@khoj.dev",
+            "sender": os.environ.get("RESEND_EMAIL", "noreply@khoj.dev"),
             "to": "team@khoj.dev",
             "subject": f"User Feedback",
             "html": html_content,
@@ -130,7 +126,7 @@ def send_task_email(name, email, query, result, subject, is_image=False):
 
     r = resend.Emails.send(
         {
-            "sender": "Khoj <khoj@khoj.dev>",
+            "sender": f'Khoj <{os.environ.get("RESEND_EMAIL", "khoj@khoj.dev")}>',
             "to": email,
             "subject": f"✨ {subject}",
             "html": html_content,