in progress, routers and main split up

crates/html-router/Cargo.toml

@@ -0,0 +1,35 @@
+[package]
+name = "html-router"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+# Workspace dependencies
+tokio = { workspace = true }
+serde = { workspace = true }
+axum = { workspace = true }
+tracing = { workspace = true }
+serde_json = { workspace = true }
+
+
+axum-htmx = "0.6.0"
+axum_session = "0.14.4"
+axum_session_auth = "0.14.1"
+axum_session_surreal = "0.2.1"
+axum_typed_multipart = "0.12.1"
+futures = "0.3.31"
+tempfile = "3.12.0"
+async-stream = "0.3.6"
+json-stream-parser = "0.1.4"
+minijinja = { version = "2.5.0", features = ["loader", "multi_template"] }
+minijinja-autoreload = "2.5.0"
+minijinja-contrib = { version = "2.6.0", features = ["datetime", "timezone"] }
+plotly = "0.12.1"
+surrealdb = "2.0.4"
+tower-http = { version = "0.6.2", features = ["fs"] }
+chrono-tz = "0.10.1"
+async-openai = "0.24.1"
+
+
+
+common = { path = "../common" }

crates/html-router/src/html_state.rs

@@ -0,0 +1,88 @@
+use axum_session::SessionStore;
+use axum_session_surreal::SessionSurrealPool;
+use common::ingress::jobqueue::JobQueue;
+use common::storage::db::SurrealDbClient;
+use common::utils::config::AppConfig;
+use common::utils::mailer::Mailer;
+use minijinja::{path_loader, Environment};
+use minijinja_autoreload::AutoReloader;
+use std::path::PathBuf;
+use std::sync::Arc;
+use surrealdb::engine::any::Any;
+
+#[derive(Clone)]
+pub struct HtmlState {
+    pub surreal_db_client: Arc<SurrealDbClient>,
+    pub openai_client: Arc<async_openai::Client<async_openai::config::OpenAIConfig>>,
+    pub templates: Arc<AutoReloader>,
+    pub mailer: Arc<Mailer>,
+    pub job_queue: Arc<JobQueue>,
+    pub session_store: Arc<SessionStore<SessionSurrealPool<Any>>>,
+}
+
+impl HtmlState {
+    pub async fn new(config: &AppConfig) -> Result<Self, Box<dyn std::error::Error>> {
+        let reloader = AutoReloader::new(move |notifier| {
+            let template_path = get_templates_dir();
+            let mut env = Environment::new();
+            env.set_loader(path_loader(&template_path));
+
+            notifier.set_fast_reload(true);
+            notifier.watch_path(&template_path, true);
+            minijinja_contrib::add_to_environment(&mut env);
+            Ok(env)
+        });
+
+        let surreal_db_client = Arc::new(
+            SurrealDbClient::new(
+                &config.surrealdb_address,
+                &config.surrealdb_username,
+                &config.surrealdb_password,
+                &config.surrealdb_namespace,
+                &config.surrealdb_database,
+            )
+            .await?,
+        );
+
+        surreal_db_client.ensure_initialized().await?;
+
+        let openai_client = Arc::new(async_openai::Client::new());
+
+        let session_store = Arc::new(surreal_db_client.create_session_store().await?);
+
+        let app_state = HtmlState {
+            surreal_db_client: surreal_db_client.clone(),
+            templates: Arc::new(reloader),
+            openai_client: openai_client.clone(),
+            mailer: Arc::new(Mailer::new(
+                &config.smtp_username,
+                &config.smtp_relayer,
+                &config.smtp_password,
+            )?),
+            job_queue: Arc::new(JobQueue::new(surreal_db_client)),
+            session_store,
+        };
+
+        Ok(app_state)
+    }
+}
+
+pub fn get_workspace_root() -> PathBuf {
+    // Starts from CARGO_MANIFEST_DIR (e.g., /project/crates/html-router/)
+    let manifest_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+
+    // Navigate up to /path/to/project/crates
+    let crates_dir = manifest_dir
+        .parent()
+        .expect("Failed to find parent of manifest directory");
+
+    // Navigate up to workspace root
+    crates_dir
+        .parent()
+        .expect("Failed to find workspace root")
+        .to_path_buf()
+}
+
+pub fn get_templates_dir() -> PathBuf {
+    get_workspace_root().join("templates")
+}

crates/html-router/src/lib.rs

@@ -0,0 +1,110 @@
+pub mod html_state;
+mod middleware_analytics;
+mod routes;
+
+use axum::{
+    extract::FromRef,
+    middleware::from_fn_with_state,
+    routing::{delete, get, patch, post},
+    Router,
+};
+use axum_session::SessionLayer;
+use axum_session_auth::{AuthConfig, AuthSessionLayer};
+use axum_session_surreal::SessionSurrealPool;
+use common::storage::types::user::User;
+use html_state::HtmlState;
+use middleware_analytics::analytics_middleware;
+use routes::{
+    account::{delete_account, set_api_key, show_account_page, update_timezone},
+    admin_panel::{show_admin_panel, toggle_registration_status},
+    chat::{
+        message_response_stream::get_response_stream, new_chat_user_message, new_user_message,
+        references::show_reference_tooltip, show_chat_base, show_existing_chat,
+        show_initialized_chat,
+    },
+    content::{patch_text_content, show_content_page, show_text_content_edit_form},
+    documentation::{
+        show_documentation_index, show_get_started, show_mobile_friendly, show_privacy_policy,
+    },
+    gdpr::{accept_gdpr, deny_gdpr},
+    index::{delete_job, delete_text_content, index_handler, show_active_jobs},
+    ingress_form::{hide_ingress_form, process_ingress_form, show_ingress_form},
+    knowledge::{
+        delete_knowledge_entity, delete_knowledge_relationship, patch_knowledge_entity,
+        save_knowledge_relationship, show_edit_knowledge_entity_form, show_knowledge_page,
+    },
+    search_result::search_result_handler,
+    signin::{authenticate_user, show_signin_form},
+    signout::sign_out_user,
+    signup::{process_signup_and_show_verification, show_signup_form},
+};
+use surrealdb::{engine::any::Any, Surreal};
+use tower_http::services::ServeDir;
+
+/// Router for HTML endpoints
+pub fn html_routes<S>(app_state: &HtmlState) -> Router<S>
+where
+    S: Clone + Send + Sync + 'static,
+    HtmlState: FromRef<S>,
+{
+    Router::new()
+        .route("/", get(index_handler))
+        .route("/gdpr/accept", post(accept_gdpr))
+        .route("/gdpr/deny", post(deny_gdpr))
+        .route("/search", get(search_result_handler))
+        .route("/chat", get(show_chat_base).post(new_chat_user_message))
+        .route("/initialized-chat", post(show_initialized_chat))
+        .route("/chat/:id", get(show_existing_chat).post(new_user_message))
+        .route("/chat/response-stream", get(get_response_stream))
+        .route("/knowledge/:id", get(show_reference_tooltip))
+        .route("/signout", get(sign_out_user))
+        .route("/signin", get(show_signin_form).post(authenticate_user))
+        .route(
+            "/ingress-form",
+            get(show_ingress_form).post(process_ingress_form),
+        )
+        .route("/hide-ingress-form", get(hide_ingress_form))
+        .route("/text-content/:id", delete(delete_text_content))
+        .route("/jobs/:job_id", delete(delete_job))
+        .route("/active-jobs", get(show_active_jobs))
+        .route("/content", get(show_content_page))
+        .route(
+            "/content/:id",
+            get(show_text_content_edit_form).patch(patch_text_content),
+        )
+        .route("/knowledge", get(show_knowledge_page))
+        .route(
+            "/knowledge-entity/:id",
+            get(show_edit_knowledge_entity_form)
+                .delete(delete_knowledge_entity)
+                .patch(patch_knowledge_entity),
+        )
+        .route("/knowledge-relationship", post(save_knowledge_relationship))
+        .route(
+            "/knowledge-relationship/:id",
+            delete(delete_knowledge_relationship),
+        )
+        .route("/account", get(show_account_page))
+        .route("/admin", get(show_admin_panel))
+        .route("/toggle-registrations", patch(toggle_registration_status))
+        .route("/set-api-key", post(set_api_key))
+        .route("/update-timezone", patch(update_timezone))
+        .route("/delete-account", delete(delete_account))
+        .route(
+            "/signup",
+            get(show_signup_form).post(process_signup_and_show_verification),
+        )
+        .route("/documentation", get(show_documentation_index))
+        .route("/documentation/privacy-policy", get(show_privacy_policy))
+        .route("/documentation/get-started", get(show_get_started))
+        .route("/documentation/mobile-friendly", get(show_mobile_friendly))
+        .nest_service("/assets", ServeDir::new("assets/"))
+        .layer(from_fn_with_state(app_state.clone(), analytics_middleware))
+        .layer(
+            AuthSessionLayer::<User, String, SessionSurrealPool<Any>, Surreal<Any>>::new(Some(
+                app_state.surreal_db_client.client.clone(),
+            ))
+            .with_config(AuthConfig::<String>::default()),
+        )
+        .layer(SessionLayer::new((*app_state.session_store).clone()))
+}

crates/html-router/src/middleware_analytics.rs

@@ -0,0 +1,33 @@
+use axum::{
+    extract::{Request, State},
+    middleware::Next,
+    response::Response,
+};
+use axum_session_surreal::SessionSurrealPool;
+use surrealdb::engine::any::Any;
+
+use common::storage::types::analytics::Analytics;
+
+use crate::html_state::HtmlState;
+
+pub async fn analytics_middleware(
+    State(state): State<HtmlState>,
+    session: axum_session::Session<SessionSurrealPool<Any>>,
+    request: Request,
+    next: Next,
+) -> Response {
+    // Get the path from the request
+    let path = request.uri().path();
+
+    // Only count if it's a main page request (not assets or other resources)
+    if !path.starts_with("/assets") && !path.starts_with("/_next") && !path.contains('.') {
+        if !session.get::<bool>("counted_visitor").unwrap_or(false) {
+            let _ = Analytics::increment_visitors(&state.surreal_db_client).await;
+            session.set("counted_visitor", true);
+        }
+
+        let _ = Analytics::increment_page_loads(&state.surreal_db_client).await;
+    }
+
+    next.run(request).await
+}

crates/html-router/src/routes/account.rs

@@ -0,0 +1,147 @@
+use axum::{
+    extract::State,
+    http::{StatusCode, Uri},
+    response::{IntoResponse, Redirect},
+    Form,
+};
+use axum_htmx::HxRedirect;
+use axum_session_auth::AuthSession;
+use axum_session_surreal::SessionSurrealPool;
+use chrono_tz::TZ_VARIANTS;
+use surrealdb::{engine::any::Any, Surreal};
+
+use common::{
+    error::{AppError, HtmlError},
+    storage::{db::delete_item, types::user::User},
+};
+
+use crate::{html_state::HtmlState, page_data};
+
+use super::{render_block, render_template};
+
+page_data!(AccountData, "auth/account_settings.html", {
+    user: User,
+    timezones: Vec<String>
+});
+
+pub async fn show_account_page(
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+) -> Result<impl IntoResponse, HtmlError> {
+    // Early return if the user is not authenticated
+    let user = match auth.current_user {
+        Some(user) => user,
+        None => return Ok(Redirect::to("/").into_response()),
+    };
+
+    let timezones = TZ_VARIANTS.iter().map(|tz| tz.to_string()).collect();
+
+    let output = render_template(
+        AccountData::template_name(),
+        AccountData { user, timezones },
+        state.templates.clone(),
+    )?;
+
+    Ok(output.into_response())
+}
+
+pub async fn set_api_key(
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+) -> Result<impl IntoResponse, HtmlError> {
+    // Early return if the user is not authenticated
+    let user = match &auth.current_user {
+        Some(user) => user,
+        None => return Ok(Redirect::to("/").into_response()),
+    };
+
+    // Generate and set the API key
+    let api_key = User::set_api_key(&user.id, &state.surreal_db_client)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    auth.cache_clear_user(user.id.to_string());
+
+    // Update the user's API key
+    let updated_user = User {
+        api_key: Some(api_key),
+        ..user.clone()
+    };
+
+    // Render the API key section block
+    let output = render_block(
+        AccountData::template_name(),
+        "api_key_section",
+        AccountData {
+            user: updated_user,
+            timezones: vec![],
+        },
+        state.templates.clone(),
+    )?;
+
+    Ok(output.into_response())
+}
+
+pub async fn delete_account(
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+) -> Result<impl IntoResponse, HtmlError> {
+    // Early return if the user is not authenticated
+    let user = match &auth.current_user {
+        Some(user) => user,
+        None => return Ok(Redirect::to("/").into_response()),
+    };
+
+    delete_item::<User>(&state.surreal_db_client, &user.id)
+        .await
+        .map_err(|e| HtmlError::new(AppError::from(e), state.templates.clone()))?;
+
+    auth.logout_user();
+
+    auth.session.destroy();
+
+    Ok((HxRedirect::from(Uri::from_static("/")), StatusCode::OK).into_response())
+}
+
+#[derive(Deserialize)]
+pub struct UpdateTimezoneForm {
+    timezone: String,
+}
+
+pub async fn update_timezone(
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+    Form(form): Form<UpdateTimezoneForm>,
+) -> Result<impl IntoResponse, HtmlError> {
+    let user = match &auth.current_user {
+        Some(user) => user,
+        None => return Ok(Redirect::to("/").into_response()),
+    };
+
+    User::update_timezone(&user.id, &form.timezone, &state.surreal_db_client)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    auth.cache_clear_user(user.id.to_string());
+
+    // Update the user's API key
+    let updated_user = User {
+        timezone: form.timezone,
+        ..user.clone()
+    };
+
+    let timezones = TZ_VARIANTS.iter().map(|tz| tz.to_string()).collect();
+
+    // Render the API key section block
+    let output = render_block(
+        AccountData::template_name(),
+        "timezone_section",
+        AccountData {
+            user: updated_user,
+            timezones,
+        },
+        state.templates.clone(),
+    )?;
+
+    Ok(output.into_response())
+}

crates/html-router/src/routes/admin_panel.rs

@@ -0,0 +1,118 @@
+use axum::{
+    extract::State,
+    response::{IntoResponse, Redirect},
+    Form,
+};
+use axum_session_auth::AuthSession;
+use axum_session_surreal::SessionSurrealPool;
+use surrealdb::{engine::any::Any, Surreal};
+
+use common::{
+    error::HtmlError,
+    storage::types::{analytics::Analytics, system_settings::SystemSettings, user::User},
+};
+
+use crate::{html_state::HtmlState, page_data};
+
+use super::{render_block, render_template};
+
+page_data!(AdminPanelData, "auth/admin_panel.html", {
+    user: User,
+    settings: SystemSettings,
+    analytics: Analytics,
+    users: i64,
+});
+
+pub async fn show_admin_panel(
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+) -> Result<impl IntoResponse, HtmlError> {
+    // Early return if the user is not authenticated and admin
+    let user = match auth.current_user {
+        Some(user) if user.admin => user,
+        _ => return Ok(Redirect::to("/").into_response()),
+    };
+
+    let settings = SystemSettings::get_current(&state.surreal_db_client)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    let analytics = Analytics::get_current(&state.surreal_db_client)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    let users_count = Analytics::get_users_amount(&state.surreal_db_client)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    let output = render_template(
+        AdminPanelData::template_name(),
+        AdminPanelData {
+            user,
+            settings,
+            analytics,
+            users: users_count,
+        },
+        state.templates.clone(),
+    )?;
+
+    Ok(output.into_response())
+}
+
+fn checkbox_to_bool<'de, D>(deserializer: D) -> Result<bool, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    match String::deserialize(deserializer) {
+        Ok(string) => Ok(string == "on"),
+        Err(_) => Ok(false),
+    }
+}
+
+#[derive(Deserialize)]
+pub struct RegistrationToggleInput {
+    #[serde(default)]
+    #[serde(deserialize_with = "checkbox_to_bool")]
+    registration_open: bool,
+}
+
+#[derive(Serialize)]
+pub struct RegistrationToggleData {
+    settings: SystemSettings,
+}
+
+pub async fn toggle_registration_status(
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+    Form(input): Form<RegistrationToggleInput>,
+) -> Result<impl IntoResponse, HtmlError> {
+    // Early return if the user is not authenticated and admin
+    let _user = match auth.current_user {
+        Some(user) if user.admin => user,
+        _ => return Ok(Redirect::to("/").into_response()),
+    };
+
+    let current_settings = SystemSettings::get_current(&state.surreal_db_client)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    let new_settings = SystemSettings {
+        registrations_enabled: input.registration_open,
+        ..current_settings.clone()
+    };
+
+    SystemSettings::update(&state.surreal_db_client, new_settings.clone())
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    let output = render_block(
+        AdminPanelData::template_name(),
+        "registration_status_input",
+        RegistrationToggleData {
+            settings: new_settings,
+        },
+        state.templates.clone(),
+    )?;
+
+    Ok(output.into_response())
+}

crates/html-router/src/routes/chat/message_response_stream.rs

@@ -0,0 +1,336 @@
+use std::{pin::Pin, sync::Arc, time::Duration};
+
+use async_stream::stream;
+use axum::{
+    extract::{Query, State},
+    response::{
+        sse::{Event, KeepAlive},
+        Sse,
+    },
+};
+use axum_session_auth::AuthSession;
+use axum_session_surreal::SessionSurrealPool;
+use futures::{
+    stream::{self, once},
+    Stream, StreamExt, TryStreamExt,
+};
+use json_stream_parser::JsonStreamParser;
+use serde::{Deserialize, Serialize};
+use serde_json::from_str;
+use surrealdb::{engine::any::Any, Surreal};
+use tokio::sync::{mpsc::channel, Mutex};
+use tracing::{error, info};
+
+use common::{
+    retrieval::{
+        combined_knowledge_entity_retrieval,
+        query_helper::{
+            create_chat_request, create_user_message, format_entities_json, LLMResponseFormat,
+        },
+    },
+    storage::{
+        db::{get_item, store_item, SurrealDbClient},
+        types::{
+            message::{Message, MessageRole},
+            user::User,
+        },
+    },
+};
+
+use crate::{html_state::HtmlState, routes::render_template};
+
+// Error handling function
+fn create_error_stream(
+    message: impl Into<String>,
+) -> Pin<Box<dyn Stream<Item = Result<Event, axum::Error>> + Send>> {
+    let message = message.into();
+    stream::once(async move { Ok(Event::default().event("error").data(message)) }).boxed()
+}
+
+// Helper function to get message and user
+async fn get_message_and_user(
+    db: &SurrealDbClient,
+    current_user: Option<User>,
+    message_id: &str,
+) -> Result<(Message, User), Sse<Pin<Box<dyn Stream<Item = Result<Event, axum::Error>> + Send>>>> {
+    // Check authentication
+    let user = match current_user {
+        Some(user) => user,
+        None => {
+            return Err(Sse::new(create_error_stream(
+                "You must be signed in to use this feature",
+            )))
+        }
+    };
+
+    // Retrieve message
+    let message = match get_item::<Message>(db, message_id).await {
+        Ok(Some(message)) => message,
+        Ok(None) => {
+            return Err(Sse::new(create_error_stream(
+                "Message not found: the specified message does not exist",
+            )))
+        }
+        Err(e) => {
+            error!("Database error retrieving message {}: {:?}", message_id, e);
+            return Err(Sse::new(create_error_stream(
+                "Failed to retrieve message: database error",
+            )));
+        }
+    };
+
+    Ok((message, user))
+}
+
+#[derive(Deserialize)]
+pub struct QueryParams {
+    message_id: String,
+}
+
+pub async fn get_response_stream(
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+    Query(params): Query<QueryParams>,
+) -> Sse<Pin<Box<dyn Stream<Item = Result<Event, axum::Error>> + Send>>> {
+    // 1. Authentication and initial data validation
+    let (user_message, user) = match get_message_and_user(
+        &state.surreal_db_client,
+        auth.current_user,
+        &params.message_id,
+    )
+    .await
+    {
+        Ok((user_message, user)) => (user_message, user),
+        Err(error_stream) => return error_stream,
+    };
+
+    // 2. Retrieve knowledge entities
+    let entities = match combined_knowledge_entity_retrieval(
+        &state.surreal_db_client,
+        &state.openai_client,
+        &user_message.content,
+        &user.id,
+    )
+    .await
+    {
+        Ok(entities) => entities,
+        Err(_e) => {
+            return Sse::new(create_error_stream("Failed to retrieve knowledge entities"));
+        }
+    };
+
+    // 3. Create the OpenAI request
+    let entities_json = format_entities_json(&entities);
+    let formatted_user_message = create_user_message(&entities_json, &user_message.content);
+    let request = match create_chat_request(formatted_user_message) {
+        Ok(req) => req,
+        Err(..) => {
+            return Sse::new(create_error_stream("Failed to create chat request"));
+        }
+    };
+
+    // 4. Set up the OpenAI stream
+    let openai_stream = match state.openai_client.chat().create_stream(request).await {
+        Ok(stream) => stream,
+        Err(_e) => {
+            return Sse::new(create_error_stream("Failed to create OpenAI stream"));
+        }
+    };
+
+    // 5. Create channel for collecting complete response
+    let (tx, mut rx) = channel::<String>(1000);
+    let tx_clone = tx.clone();
+    let (tx_final, mut rx_final) = channel::<Message>(1);
+
+    // 6. Set up the collection task for DB storage
+    let db_client = state.surreal_db_client.clone();
+    tokio::spawn(async move {
+        drop(tx); // Close sender when no longer needed
+
+        // Collect full response
+        let mut full_json = String::new();
+        while let Some(chunk) = rx.recv().await {
+            full_json.push_str(&chunk);
+        }
+
+        // Try to extract structured data
+        if let Ok(response) = from_str::<LLMResponseFormat>(&full_json) {
+            let references: Vec<String> = response
+                .references
+                .into_iter()
+                .map(|r| r.reference)
+                .collect();
+
+            let ai_message = Message::new(
+                user_message.conversation_id,
+                MessageRole::AI,
+                response.answer,
+                Some(references),
+            );
+
+            let _ = tx_final.send(ai_message.clone()).await;
+
+            match store_item(&db_client, ai_message).await {
+                Ok(_) => info!("Successfully stored AI message with references"),
+                Err(e) => error!("Failed to store AI message: {:?}", e),
+            }
+        } else {
+            error!("Failed to parse LLM response as structured format");
+
+            // Fallback - store raw response
+            let ai_message = Message::new(
+                user_message.conversation_id,
+                MessageRole::AI,
+                full_json,
+                None,
+            );
+
+            let _ = store_item(&db_client, ai_message).await;
+        }
+    });
+
+    // Create a shared state for tracking the JSON parsing
+    let json_state = Arc::new(Mutex::new(StreamParserState::new()));
+
+    // 7. Create the response event stream
+    let event_stream = openai_stream
+        .map_err(|e| Box::new(e) as Box<dyn std::error::Error + Send + Sync>)
+        .map(move |result| {
+            let tx_storage = tx_clone.clone();
+            let json_state = json_state.clone();
+
+            stream! {
+                match result {
+                    Ok(response) => {
+                        let content = response
+                            .choices
+                            .first()
+                            .and_then(|choice| choice.delta.content.clone())
+                            .unwrap_or_default();
+
+                        if !content.is_empty() {
+                            // Always send raw content to storage
+                            let _ = tx_storage.send(content.clone()).await;
+
+                            // Process through JSON parser
+                            let mut state = json_state.lock().await;
+                            let display_content = state.process_chunk(&content);
+                            drop(state);
+                            if !display_content.is_empty() {
+                                yield Ok(Event::default()
+                                    .event("chat_message")
+                                    .data(display_content));
+                            }
+                            // If display_content is empty, don't yield anything
+                        }
+                        // If content is empty, don't yield anything
+                    }
+                    Err(e) => {
+                        yield Ok(Event::default()
+                            .event("error")
+                            .data(format!("Stream error: {}", e)));
+                    }
+                }
+            }
+        })
+        .flatten()
+        .chain(stream::once(async move {
+            if let Some(message) = rx_final.recv().await {
+                // Don't send any event if references is empty
+                if message.references.as_ref().is_some_and(|x| x.is_empty()) {
+                    return Ok(Event::default().event("empty")); // This event won't be sent
+                }
+
+                // Prepare data for template
+                #[derive(Serialize)]
+                struct ReferenceData {
+                    message: Message,
+                }
+
+                // Render template with references
+                match render_template(
+                    "chat/reference_list.html",
+                    ReferenceData { message },
+                    state.templates.clone(),
+                ) {
+                    Ok(html) => {
+                        // Extract the String from Html<String>
+                        let html_string = html.0;
+
+                        // Return the rendered HTML
+                        Ok(Event::default().event("references").data(html_string))
+                    }
+                    Err(_) => {
+                        // Handle template rendering error
+                        Ok(Event::default()
+                            .event("error")
+                            .data("Failed to render references"))
+                    }
+                }
+            } else {
+                // Handle case where no references were received
+                Ok(Event::default()
+                    .event("error")
+                    .data("Failed to retrieve references"))
+            }
+        }))
+        .chain(once(async {
+            Ok(Event::default()
+                .event("close_stream")
+                .data("Stream complete"))
+        }));
+
+    info!("OpenAI streaming started");
+    Sse::new(event_stream.boxed()).keep_alive(
+        KeepAlive::new()
+            .interval(Duration::from_secs(15))
+            .text("keep-alive"),
+    )
+}
+
+// Replace JsonParseState with StreamParserState
+struct StreamParserState {
+    parser: JsonStreamParser,
+    last_answer_content: String,
+    in_answer_field: bool,
+}
+
+impl StreamParserState {
+    fn new() -> Self {
+        Self {
+            parser: JsonStreamParser::new(),
+            last_answer_content: String::new(),
+            in_answer_field: false,
+        }
+    }
+
+    fn process_chunk(&mut self, chunk: &str) -> String {
+        // Feed all characters into the parser
+        for c in chunk.chars() {
+            let _ = self.parser.add_char(c);
+        }
+
+        // Get the current state of the JSON
+        let json = self.parser.get_result();
+
+        // Check if we're in the answer field
+        if let Some(obj) = json.as_object() {
+            if let Some(answer) = obj.get("answer") {
+                self.in_answer_field = true;
+
+                // Get current answer content
+                let current_content = answer.as_str().unwrap_or_default().to_string();
+
+                // Calculate difference to send only new content
+                if current_content.len() > self.last_answer_content.len() {
+                    let new_content = current_content[self.last_answer_content.len()..].to_string();
+                    self.last_answer_content = current_content;
+                    return new_content;
+                }
+            }
+        }
+
+        // No new content to return
+        String::new()
+    }
+}

crates/html-router/src/routes/chat/mod.rs

@@ -0,0 +1,289 @@
+pub mod message_response_stream;
+pub mod references;
+
+use axum::{
+    extract::{Path, State},
+    http::HeaderValue,
+    response::{IntoResponse, Redirect},
+    Form,
+};
+use axum_session_auth::AuthSession;
+use axum_session_surreal::SessionSurrealPool;
+use surrealdb::{engine::any::Any, Surreal};
+use tracing::info;
+
+use common::{
+    error::{AppError, HtmlError},
+    storage::{
+        db::{get_item, store_item},
+        types::{
+            conversation::Conversation,
+            message::{Message, MessageRole},
+            user::User,
+        },
+    },
+};
+
+use crate::{html_state::HtmlState, page_data, routes::render_template};
+
+// Update your ChatStartParams struct to properly deserialize the references
+#[derive(Debug, Deserialize)]
+pub struct ChatStartParams {
+    user_query: String,
+    llm_response: String,
+    #[serde(deserialize_with = "deserialize_references")]
+    references: Vec<String>,
+}
+
+// Custom deserializer function
+fn deserialize_references<'de, D>(deserializer: D) -> Result<Vec<String>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    let s = String::deserialize(deserializer)?;
+    serde_json::from_str(&s).map_err(serde::de::Error::custom)
+}
+
+page_data!(ChatData, "chat/base.html", {
+    user: User,
+    history: Vec<Message>,
+    conversation: Option<Conversation>,
+    conversation_archive: Vec<Conversation>
+});
+
+pub async fn show_initialized_chat(
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+    Form(form): Form<ChatStartParams>,
+) -> Result<impl IntoResponse, HtmlError> {
+    info!("Displaying chat start");
+
+    let user = match auth.current_user {
+        Some(user) => user,
+        None => return Ok(Redirect::to("/").into_response()),
+    };
+
+    let conversation = Conversation::new(user.id.clone(), "Test".to_owned());
+
+    let user_message = Message::new(
+        conversation.id.to_string(),
+        MessageRole::User,
+        form.user_query,
+        None,
+    );
+
+    let ai_message = Message::new(
+        conversation.id.to_string(),
+        MessageRole::AI,
+        form.llm_response,
+        Some(form.references),
+    );
+
+    let (conversation_result, ai_message_result, user_message_result) = futures::join!(
+        store_item(&state.surreal_db_client, conversation.clone()),
+        store_item(&state.surreal_db_client, ai_message.clone()),
+        store_item(&state.surreal_db_client, user_message.clone())
+    );
+
+    // Check each result individually
+    conversation_result.map_err(|e| HtmlError::new(AppError::from(e), state.templates.clone()))?;
+    user_message_result.map_err(|e| HtmlError::new(AppError::from(e), state.templates.clone()))?;
+    ai_message_result.map_err(|e| HtmlError::new(AppError::from(e), state.templates.clone()))?;
+
+    let conversation_archive = User::get_user_conversations(&user.id, &state.surreal_db_client)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    let messages = vec![user_message, ai_message];
+
+    let output = render_template(
+        ChatData::template_name(),
+        ChatData {
+            history: messages,
+            user,
+            conversation_archive,
+            conversation: Some(conversation.clone()),
+        },
+        state.templates.clone(),
+    )?;
+
+    let mut response = output.into_response();
+    response.headers_mut().insert(
+        "HX-Push",
+        HeaderValue::from_str(&format!("/chat/{}", conversation.id)).unwrap(),
+    );
+    Ok(response)
+}
+
+pub async fn show_chat_base(
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+) -> Result<impl IntoResponse, HtmlError> {
+    info!("Displaying empty chat start");
+
+    let user = match auth.current_user {
+        Some(user) => user,
+        None => return Ok(Redirect::to("/").into_response()),
+    };
+
+    let conversation_archive = User::get_user_conversations(&user.id, &state.surreal_db_client)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    let output = render_template(
+        ChatData::template_name(),
+        ChatData {
+            history: vec![],
+            user,
+            conversation_archive,
+            conversation: None,
+        },
+        state.templates.clone(),
+    )?;
+
+    Ok(output.into_response())
+}
+
+#[derive(Deserialize)]
+pub struct NewMessageForm {
+    content: String,
+}
+
+pub async fn show_existing_chat(
+    Path(conversation_id): Path<String>,
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+) -> Result<impl IntoResponse, HtmlError> {
+    info!("Displaying initialized chat with id: {}", conversation_id);
+
+    let user = match auth.current_user {
+        Some(user) => user,
+        None => return Ok(Redirect::to("/").into_response()),
+    };
+
+    let conversation_archive = User::get_user_conversations(&user.id, &state.surreal_db_client)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    let (conversation, messages) = Conversation::get_complete_conversation(
+        conversation_id.as_str(),
+        &user.id,
+        &state.surreal_db_client,
+    )
+    .await
+    .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    let output = render_template(
+        ChatData::template_name(),
+        ChatData {
+            history: messages,
+            user,
+            conversation: Some(conversation.clone()),
+            conversation_archive,
+        },
+        state.templates.clone(),
+    )?;
+
+    Ok(output.into_response())
+}
+
+pub async fn new_user_message(
+    Path(conversation_id): Path<String>,
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+    Form(form): Form<NewMessageForm>,
+) -> Result<impl IntoResponse, HtmlError> {
+    let user = match auth.current_user {
+        Some(user) => user,
+        None => return Ok(Redirect::to("/").into_response()),
+    };
+
+    let conversation: Conversation = get_item(&state.surreal_db_client, &conversation_id)
+        .await
+        .map_err(|e| HtmlError::new(AppError::from(e), state.templates.clone()))?
+        .ok_or_else(|| {
+            HtmlError::new(
+                AppError::NotFound("Conversation was not found".to_string()),
+                state.templates.clone(),
+            )
+        })?;
+
+    if conversation.user_id != user.id {
+        return Err(HtmlError::new(
+            AppError::Auth("The user does not have permission for this conversation".to_string()),
+            state.templates.clone(),
+        ));
+    };
+
+    let user_message = Message::new(conversation_id, MessageRole::User, form.content, None);
+
+    store_item(&state.surreal_db_client, user_message.clone())
+        .await
+        .map_err(|e| HtmlError::new(AppError::from(e), state.templates.clone()))?;
+
+    #[derive(Serialize)]
+    struct SSEResponseInitData {
+        user_message: Message,
+    }
+
+    let output = render_template(
+        "chat/streaming_response.html",
+        SSEResponseInitData { user_message },
+        state.templates.clone(),
+    )?;
+
+    let mut response = output.into_response();
+    response.headers_mut().insert(
+        "HX-Push",
+        HeaderValue::from_str(&format!("/chat/{}", conversation.id)).unwrap(),
+    );
+    Ok(response)
+}
+
+pub async fn new_chat_user_message(
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+    Form(form): Form<NewMessageForm>,
+) -> Result<impl IntoResponse, HtmlError> {
+    let user = match auth.current_user {
+        Some(user) => user,
+        None => return Ok(Redirect::to("/").into_response()),
+    };
+
+    let conversation = Conversation::new(user.id, "New chat".to_string());
+    let user_message = Message::new(
+        conversation.id.clone(),
+        MessageRole::User,
+        form.content,
+        None,
+    );
+
+    store_item(&state.surreal_db_client, conversation.clone())
+        .await
+        .map_err(|e| HtmlError::new(AppError::from(e), state.templates.clone()))?;
+    store_item(&state.surreal_db_client, user_message.clone())
+        .await
+        .map_err(|e| HtmlError::new(AppError::from(e), state.templates.clone()))?;
+
+    #[derive(Serialize)]
+    struct SSEResponseInitData {
+        user_message: Message,
+        conversation: Conversation,
+    }
+
+    let output = render_template(
+        "chat/new_chat_first_response.html",
+        SSEResponseInitData {
+            user_message,
+            conversation: conversation.clone(),
+        },
+        state.templates.clone(),
+    )?;
+
+    let mut response = output.into_response();
+    response.headers_mut().insert(
+        "HX-Push",
+        HeaderValue::from_str(&format!("/chat/{}", conversation.id)).unwrap(),
+    );
+    Ok(response)
+}

crates/html-router/src/routes/chat/references.rs

@@ -0,0 +1,63 @@
+use axum::{
+    extract::{Path, State},
+    response::{IntoResponse, Redirect},
+};
+use axum_session_auth::AuthSession;
+use axum_session_surreal::SessionSurrealPool;
+use serde::Serialize;
+use surrealdb::{engine::any::Any, Surreal};
+use tracing::info;
+
+use common::{
+    error::{AppError, HtmlError},
+    storage::{
+        db::get_item,
+        types::{knowledge_entity::KnowledgeEntity, user::User},
+    },
+};
+
+use crate::{html_state::HtmlState, routes::render_template};
+
+pub async fn show_reference_tooltip(
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+    Path(reference_id): Path<String>,
+) -> Result<impl IntoResponse, HtmlError> {
+    info!("Showing reference");
+
+    let user = match auth.current_user {
+        Some(user) => user,
+        None => return Ok(Redirect::to("/").into_response()),
+    };
+
+    let entity: KnowledgeEntity = get_item(&state.surreal_db_client, &reference_id)
+        .await
+        .map_err(|e| HtmlError::new(AppError::from(e), state.templates.clone()))?
+        .ok_or_else(|| {
+            HtmlError::new(
+                AppError::NotFound("Item was not found".to_string()),
+                state.templates.clone(),
+            )
+        })?;
+
+    if entity.user_id != user.id {
+        return Err(HtmlError::new(
+            AppError::Auth("You dont have access to this entity".to_string()),
+            state.templates.clone(),
+        ));
+    }
+
+    #[derive(Serialize)]
+    struct ReferenceTooltipData {
+        entity: KnowledgeEntity,
+        user: User,
+    }
+
+    let output = render_template(
+        "chat/reference_tooltip.html",
+        ReferenceTooltipData { entity, user },
+        state.templates.clone(),
+    )?;
+
+    Ok(output.into_response())
+}

crates/html-router/src/routes/content/mod.rs

@@ -0,0 +1,108 @@
+use axum::{
+    extract::{Path, State},
+    response::{IntoResponse, Redirect},
+};
+use axum_session_auth::AuthSession;
+use axum_session_surreal::SessionSurrealPool;
+use surrealdb::{engine::any::Any, Surreal};
+
+use common::{
+    error::HtmlError,
+    storage::types::{text_content::TextContent, user::User},
+};
+
+use crate::{html_state::HtmlState, page_data};
+
+use super::render_template;
+
+page_data!(ContentPageData, "content/base.html", {
+    user: User,
+    text_contents: Vec<TextContent>
+});
+
+pub async fn show_content_page(
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+) -> Result<impl IntoResponse, HtmlError> {
+    // Early return if the user is not authenticated
+    let user = match auth.current_user {
+        Some(user) => user,
+        None => return Ok(Redirect::to("/signin").into_response()),
+    };
+
+    let text_contents = User::get_text_contents(&user.id, &state.surreal_db_client)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    let output = render_template(
+        ContentPageData::template_name(),
+        ContentPageData {
+            user,
+            text_contents,
+        },
+        state.templates,
+    )?;
+
+    Ok(output.into_response())
+}
+
+#[derive(Serialize)]
+pub struct TextContentEditModal {
+    pub user: User,
+    pub text_content: TextContent,
+}
+
+pub async fn show_text_content_edit_form(
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+    Path(id): Path<String>,
+) -> Result<impl IntoResponse, HtmlError> {
+    // Early return if the user is not authenticated
+    let user = match auth.current_user {
+        Some(user) => user,
+        None => return Ok(Redirect::to("/signin").into_response()),
+    };
+
+    let text_content = User::get_and_validate_text_content(&id, &user.id, &state.surreal_db_client)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    let output = render_template(
+        "content/edit_text_content_modal.html",
+        TextContentEditModal { user, text_content },
+        state.templates,
+    )?;
+
+    Ok(output.into_response())
+}
+
+pub async fn patch_text_content(
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+    Path(id): Path<String>,
+) -> Result<impl IntoResponse, HtmlError> {
+    // Early return if the user is not authenticated
+    let user = match auth.current_user {
+        Some(user) => user,
+        None => return Ok(Redirect::to("/signin").into_response()),
+    };
+
+    let text_content = User::get_and_validate_text_content(&id, &user.id, &state.surreal_db_client)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    let text_contents = User::get_text_contents(&user.id, &state.surreal_db_client)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    let output = render_template(
+        "content/content_list.html",
+        ContentPageData {
+            user,
+            text_contents,
+        },
+        state.templates,
+    )?;
+
+    Ok(output.into_response())
+}

crates/html-router/src/routes/documentation/mod.rs

@@ -0,0 +1,78 @@
+use axum::{extract::State, response::IntoResponse};
+use axum_session_auth::AuthSession;
+use axum_session_surreal::SessionSurrealPool;
+use surrealdb::{engine::any::Any, Surreal};
+
+use common::{error::HtmlError, storage::types::user::User};
+
+use crate::{html_state::HtmlState, page_data};
+
+use super::render_template;
+
+page_data!(DocumentationData, "do_not_use_this", {
+    user: Option<User>,
+    current_path: String
+});
+
+pub async fn show_privacy_policy(
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+) -> Result<impl IntoResponse, HtmlError> {
+    let output = render_template(
+        "documentation/privacy.html",
+        DocumentationData {
+            user: auth.current_user,
+            current_path: "/privacy_policy".to_string(),
+        },
+        state.templates.clone(),
+    )?;
+
+    Ok(output.into_response())
+}
+
+pub async fn show_get_started(
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+) -> Result<impl IntoResponse, HtmlError> {
+    let output = render_template(
+        "documentation/get_started.html",
+        DocumentationData {
+            user: auth.current_user,
+            current_path: "/get-started".to_string(),
+        },
+        state.templates.clone(),
+    )?;
+
+    Ok(output.into_response())
+}
+pub async fn show_mobile_friendly(
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+) -> Result<impl IntoResponse, HtmlError> {
+    let output = render_template(
+        "documentation/mobile_friendly.html",
+        DocumentationData {
+            user: auth.current_user,
+            current_path: "/mobile-friendly".to_string(),
+        },
+        state.templates.clone(),
+    )?;
+
+    Ok(output.into_response())
+}
+
+pub async fn show_documentation_index(
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+) -> Result<impl IntoResponse, HtmlError> {
+    let output = render_template(
+        "documentation/index.html",
+        DocumentationData {
+            user: auth.current_user,
+            current_path: "/index".to_string(),
+        },
+        state.templates.clone(),
+    )?;
+
+    Ok(output.into_response())
+}

crates/html-router/src/routes/gdpr.rs

@@ -0,0 +1,22 @@
+use axum::response::{Html, IntoResponse};
+use axum_session::Session;
+use axum_session_surreal::SessionSurrealPool;
+use surrealdb::engine::any::Any;
+
+use common::error::HtmlError;
+
+pub async fn accept_gdpr(
+    session: Session<SessionSurrealPool<Any>>,
+) -> Result<impl IntoResponse, HtmlError> {
+    session.set("gdpr_accepted", true);
+
+    Ok(Html("").into_response())
+}
+
+pub async fn deny_gdpr(
+    session: Session<SessionSurrealPool<Any>>,
+) -> Result<impl IntoResponse, HtmlError> {
+    session.set("gdpr_accepted", true);
+
+    Ok(Html("").into_response())
+}

crates/html-router/src/routes/index.rs

@@ -0,0 +1,246 @@
+use axum::{
+    extract::{Path, State},
+    response::{IntoResponse, Redirect},
+};
+use axum_session::Session;
+use axum_session_auth::AuthSession;
+use axum_session_surreal::SessionSurrealPool;
+use surrealdb::{engine::any::Any, Surreal};
+use tokio::join;
+use tracing::info;
+
+use common::{
+    error::{AppError, HtmlError},
+    storage::{
+        db::{delete_item, get_item},
+        types::{
+            file_info::FileInfo, job::Job, knowledge_entity::KnowledgeEntity,
+            knowledge_relationship::KnowledgeRelationship, text_chunk::TextChunk,
+            text_content::TextContent, user::User,
+        },
+    },
+};
+
+use crate::{html_state::HtmlState, page_data, routes::render_template};
+
+use super::render_block;
+
+page_data!(IndexData, "index/index.html", {
+    gdpr_accepted: bool,
+    user: Option<User>,
+    latest_text_contents: Vec<TextContent>,
+    active_jobs: Vec<Job>
+});
+
+pub async fn index_handler(
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+    session: Session<SessionSurrealPool<Any>>,
+) -> Result<impl IntoResponse, HtmlError> {
+    info!("Displaying index page");
+
+    let gdpr_accepted = auth.current_user.is_some() | session.get("gdpr_accepted").unwrap_or(false);
+
+    let active_jobs = match auth.current_user.is_some() {
+        true => state
+            .job_queue
+            .get_unfinished_user_jobs(&auth.current_user.clone().unwrap().id)
+            .await
+            .map_err(|e| HtmlError::new(e, state.templates.clone()))?,
+        false => vec![],
+    };
+
+    let latest_text_contents = match auth.current_user.clone().is_some() {
+        true => User::get_latest_text_contents(
+            auth.current_user.clone().unwrap().id.as_str(),
+            &state.surreal_db_client,
+        )
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?,
+        false => vec![],
+    };
+
+    // let latest_knowledge_entities = match auth.current_user.is_some() {
+    //     true => User::get_latest_knowledge_entities(
+    //         auth.current_user.clone().unwrap().id.as_str(),
+    //         &state.surreal_db_client,
+    //     )
+    //     .await
+    //     .map_err(|e| HtmlError::new(e, state.templates.clone()))?,
+    //     false => vec![],
+    // };
+
+    let output = render_template(
+        IndexData::template_name(),
+        IndexData {
+            gdpr_accepted,
+            user: auth.current_user,
+            latest_text_contents,
+            active_jobs,
+        },
+        state.templates.clone(),
+    )?;
+
+    Ok(output.into_response())
+}
+
+#[derive(Serialize)]
+pub struct LatestTextContentData {
+    latest_text_contents: Vec<TextContent>,
+    user: User,
+}
+
+pub async fn delete_text_content(
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+    Path(id): Path<String>,
+) -> Result<impl IntoResponse, HtmlError> {
+    let user = match &auth.current_user {
+        Some(user) => user,
+        None => return Ok(Redirect::to("/").into_response()),
+    };
+
+    // Get and validate TextContent
+    let text_content = get_and_validate_text_content(&state, &id, user).await?;
+
+    // Perform concurrent deletions
+    let deletion_tasks = join!(
+        async {
+            if let Some(file_info) = text_content.file_info {
+                FileInfo::delete_by_id(&file_info.id, &state.surreal_db_client).await
+            } else {
+                Ok(())
+            }
+        },
+        delete_item::<TextContent>(&state.surreal_db_client, &text_content.id),
+        TextChunk::delete_by_source_id(&text_content.id, &state.surreal_db_client),
+        KnowledgeEntity::delete_by_source_id(&text_content.id, &state.surreal_db_client),
+        KnowledgeRelationship::delete_relationships_by_source_id(
+            &text_content.id,
+            &state.surreal_db_client
+        )
+    );
+
+    // Handle potential errors from concurrent operations
+    match deletion_tasks {
+        (Ok(_), Ok(_), Ok(_), Ok(_), Ok(_)) => (),
+        _ => {
+            return Err(HtmlError::new(
+                AppError::Processing("Failed to delete one or more items".to_string()),
+                state.templates.clone(),
+            ))
+        }
+    }
+
+    // Render updated content
+    let latest_text_contents = User::get_latest_text_contents(&user.id, &state.surreal_db_client)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    let output = render_block(
+        "index/signed_in/recent_content.html",
+        "latest_content_section",
+        LatestTextContentData {
+            user: user.clone(),
+            latest_text_contents,
+        },
+        state.templates.clone(),
+    )?;
+
+    Ok(output.into_response())
+}
+
+// Helper function to get and validate text content
+async fn get_and_validate_text_content(
+    state: &HtmlState,
+    id: &str,
+    user: &User,
+) -> Result<TextContent, HtmlError> {
+    let text_content = get_item::<TextContent>(&state.surreal_db_client, id)
+        .await
+        .map_err(|e| HtmlError::new(AppError::from(e), state.templates.clone()))?
+        .ok_or_else(|| {
+            HtmlError::new(
+                AppError::NotFound("No item found".to_string()),
+                state.templates.clone(),
+            )
+        })?;
+
+    if text_content.user_id != user.id {
+        return Err(HtmlError::new(
+            AppError::Auth("You are not the owner of that content".to_string()),
+            state.templates.clone(),
+        ));
+    }
+
+    Ok(text_content)
+}
+
+#[derive(Serialize)]
+pub struct ActiveJobsData {
+    pub active_jobs: Vec<Job>,
+    pub user: User,
+}
+
+pub async fn delete_job(
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+    Path(id): Path<String>,
+) -> Result<impl IntoResponse, HtmlError> {
+    let user = match auth.current_user {
+        Some(user) => user,
+        None => return Ok(Redirect::to("/signin").into_response()),
+    };
+
+    state
+        .job_queue
+        .delete_job(&id, &user.id)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    let active_jobs = state
+        .job_queue
+        .get_unfinished_user_jobs(&user.id)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    let output = render_block(
+        "index/signed_in/active_jobs.html",
+        "active_jobs_section",
+        ActiveJobsData {
+            user: user.clone(),
+            active_jobs,
+        },
+        state.templates.clone(),
+    )?;
+
+    Ok(output.into_response())
+}
+
+pub async fn show_active_jobs(
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+) -> Result<impl IntoResponse, HtmlError> {
+    let user = match auth.current_user {
+        Some(user) => user,
+        None => return Ok(Redirect::to("/signin").into_response()),
+    };
+
+    let active_jobs = state
+        .job_queue
+        .get_unfinished_user_jobs(&user.id)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    let output = render_block(
+        "index/signed_in/active_jobs.html",
+        "active_jobs_section",
+        ActiveJobsData {
+            user: user.clone(),
+            active_jobs,
+        },
+        state.templates.clone(),
+    )?;
+
+    Ok(output.into_response())
+}

crates/html-router/src/routes/ingress_form.rs

@@ -0,0 +1,154 @@
+use axum::{
+    extract::State,
+    response::{Html, IntoResponse, Redirect},
+};
+use axum_session_auth::AuthSession;
+use axum_session_surreal::SessionSurrealPool;
+use axum_typed_multipart::{FieldData, TryFromMultipart, TypedMultipart};
+use futures::{future::try_join_all, TryFutureExt};
+use surrealdb::{engine::any::Any, Surreal};
+use tempfile::NamedTempFile;
+use tracing::info;
+
+use common::{
+    error::{AppError, HtmlError, IntoHtmlError},
+    ingress::ingress_input::{create_ingress_objects, IngressInput},
+    storage::types::{file_info::FileInfo, user::User},
+};
+
+use crate::{
+    html_state::HtmlState,
+    page_data,
+    routes::{index::ActiveJobsData, render_block},
+};
+
+use super::render_template;
+
+#[derive(Serialize)]
+pub struct ShowIngressFormData {
+    user_categories: Vec<String>,
+}
+
+pub async fn show_ingress_form(
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+) -> Result<impl IntoResponse, HtmlError> {
+    if !auth.is_authenticated() {
+        return Ok(Redirect::to("/").into_response());
+    }
+
+    let user_categories = User::get_user_categories(&auth.id, &state.surreal_db_client)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    let output = render_template(
+        "index/signed_in/ingress_modal.html",
+        ShowIngressFormData { user_categories },
+        state.templates.clone(),
+    )?;
+
+    Ok(output.into_response())
+}
+
+pub async fn hide_ingress_form(
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+) -> Result<impl IntoResponse, HtmlError> {
+    if !auth.is_authenticated() {
+        return Ok(Redirect::to("/").into_response());
+    }
+
+    Ok(Html(
+        "<a class='btn btn-primary' hx-get='/ingress-form' hx-swap='outerHTML'>Add Content</a>",
+    )
+    .into_response())
+}
+
+#[derive(Debug, TryFromMultipart)]
+pub struct IngressParams {
+    pub content: Option<String>,
+    pub instructions: String,
+    pub category: String,
+    #[form_data(limit = "10000000")] // Adjust limit as needed
+    #[form_data(default)]
+    pub files: Vec<FieldData<NamedTempFile>>,
+}
+
+page_data!(IngressFormData, "ingress_form.html", {
+    instructions: String,
+    content: String,
+    category: String,
+    error: String,
+});
+
+pub async fn process_ingress_form(
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+    TypedMultipart(input): TypedMultipart<IngressParams>,
+) -> Result<impl IntoResponse, HtmlError> {
+    let user = auth.current_user.ok_or_else(|| {
+        AppError::Auth("You must be signed in".to_string()).with_template(state.templates.clone())
+    })?;
+
+    if input.content.clone().is_some_and(|c| c.len() < 2) && input.files.is_empty() {
+        let output = render_template(
+            IngressFormData::template_name(),
+            IngressFormData {
+                instructions: input.instructions.clone(),
+                content: input.content.clone().unwrap(),
+                category: input.category.clone(),
+                error: "You need to either add files or content".to_string(),
+            },
+            state.templates.clone(),
+        )?;
+
+        return Ok(output.into_response());
+    }
+
+    info!("{:?}", input);
+
+    let file_infos = try_join_all(input.files.into_iter().map(|file| {
+        FileInfo::new(file, &state.surreal_db_client, &user.id)
+            .map_err(|e| HtmlError::new(AppError::from(e), state.templates.clone()))
+    }))
+    .await?;
+
+    let ingress_objects = create_ingress_objects(
+        IngressInput {
+            content: input.content,
+            instructions: input.instructions,
+            category: input.category,
+            files: file_infos,
+        },
+        user.id.as_str(),
+    )
+    .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    let futures: Vec<_> = ingress_objects
+        .into_iter()
+        .map(|object| state.job_queue.enqueue(object.clone(), user.id.clone()))
+        .collect();
+
+    try_join_all(futures)
+        .await
+        .map_err(AppError::from)
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    // Update the active jobs page with the newly created job
+    let active_jobs = state
+        .job_queue
+        .get_unfinished_user_jobs(&user.id)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    let output = render_block(
+        "index/signed_in/active_jobs.html",
+        "active_jobs_section",
+        ActiveJobsData {
+            user: user.clone(),
+            active_jobs,
+        },
+        state.templates.clone(),
+    )?;
+
+    Ok(output.into_response())
+}

crates/html-router/src/routes/knowledge/mod.rs

@@ -0,0 +1,379 @@
+use axum::{
+    extract::{Path, State},
+    response::{IntoResponse, Redirect},
+    Form,
+};
+use axum_session_auth::AuthSession;
+use axum_session_surreal::SessionSurrealPool;
+use plotly::{
+    common::{Line, Marker, Mode},
+    layout::{Axis, Camera, LayoutScene, ProjectionType},
+    Layout, Plot, Scatter3D,
+};
+use surrealdb::{engine::any::Any, Surreal};
+use tracing::info;
+
+use common::{
+    error::{AppError, HtmlError},
+    storage::{
+        db::delete_item,
+        types::{
+            knowledge_entity::{KnowledgeEntity, KnowledgeEntityType},
+            knowledge_relationship::KnowledgeRelationship,
+            user::User,
+        },
+    },
+};
+
+use crate::{html_state::HtmlState, page_data, routes::render_template};
+
+page_data!(KnowledgeBaseData, "knowledge/base.html", {
+    entities: Vec<KnowledgeEntity>,
+    relationships: Vec<KnowledgeRelationship>,
+    user: User,
+    plot_html: String
+});
+
+pub async fn show_knowledge_page(
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+) -> Result<impl IntoResponse, HtmlError> {
+    // Early return if the user is not authenticated
+    let user = match auth.current_user {
+        Some(user) => user,
+        None => return Ok(Redirect::to("/signin").into_response()),
+    };
+
+    let entities = User::get_knowledge_entities(&user.id, &state.surreal_db_client)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    info!("Got entities ok");
+
+    let relationships = User::get_knowledge_relationships(&user.id, &state.surreal_db_client)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    let mut plot = Plot::new();
+
+    // Fibonacci sphere distribution
+    let node_count = entities.len();
+    let golden_ratio = (1.0 + 5.0_f64.sqrt()) / 2.0;
+    let node_positions: Vec<(f64, f64, f64)> = (0..node_count)
+        .map(|i| {
+            let i = i as f64;
+            let theta = 2.0 * std::f64::consts::PI * i / golden_ratio;
+            let phi = (1.0 - 2.0 * (i + 0.5) / node_count as f64).acos();
+            let x = phi.sin() * theta.cos();
+            let y = phi.sin() * theta.sin();
+            let z = phi.cos();
+            (x, y, z)
+        })
+        .collect();
+
+    let node_x: Vec<f64> = node_positions.iter().map(|(x, _, _)| *x).collect();
+    let node_y: Vec<f64> = node_positions.iter().map(|(_, y, _)| *y).collect();
+    let node_z: Vec<f64> = node_positions.iter().map(|(_, _, z)| *z).collect();
+
+    // Nodes trace
+    let nodes = Scatter3D::new(node_x.clone(), node_y.clone(), node_z.clone())
+        .mode(Mode::Markers)
+        .marker(Marker::new().size(8).color("#1f77b4"))
+        .text_array(
+            entities
+                .iter()
+                .map(|e| e.description.clone())
+                .collect::<Vec<_>>(),
+        )
+        .hover_template("Entity: %{text}<br>");
+
+    // Edges traces
+    for rel in &relationships {
+        let from_idx = entities.iter().position(|e| e.id == rel.out).unwrap_or(0);
+        let to_idx = entities.iter().position(|e| e.id == rel.in_).unwrap_or(0);
+
+        let edge_x = vec![node_x[from_idx], node_x[to_idx]];
+        let edge_y = vec![node_y[from_idx], node_y[to_idx]];
+        let edge_z = vec![node_z[from_idx], node_z[to_idx]];
+
+        let edge_trace = Scatter3D::new(edge_x, edge_y, edge_z)
+            .mode(Mode::Lines)
+            .line(Line::new().color("#888").width(2.0))
+            .hover_template(&format!(
+                "Relationship: {}<br>",
+                rel.metadata.relationship_type
+            ))
+            .show_legend(false);
+
+        plot.add_trace(edge_trace);
+    }
+    plot.add_trace(nodes);
+
+    // Layout
+    let layout = Layout::new()
+        .scene(
+            LayoutScene::new()
+                .x_axis(Axis::new().visible(false))
+                .y_axis(Axis::new().visible(false))
+                .z_axis(Axis::new().visible(false))
+                .camera(
+                    Camera::new()
+                        .projection(ProjectionType::Perspective.into())
+                        .eye((1.5, 1.5, 1.5).into()),
+                ),
+        )
+        .show_legend(false)
+        .paper_background_color("rbga(250,100,0,0)")
+        .plot_background_color("rbga(0,0,0,0)");
+
+    plot.set_layout(layout);
+    // Convert to HTML
+    let html = plot.to_html();
+
+    let output = render_template(
+        KnowledgeBaseData::template_name(),
+        KnowledgeBaseData {
+            entities,
+            relationships,
+            user,
+            plot_html: html,
+        },
+        state.templates,
+    )?;
+
+    Ok(output.into_response())
+}
+
+#[derive(Serialize)]
+pub struct EntityData {
+    entity: KnowledgeEntity,
+    entity_types: Vec<String>,
+    user: User,
+}
+
+pub async fn show_edit_knowledge_entity_form(
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+    Path(id): Path<String>,
+) -> Result<impl IntoResponse, HtmlError> {
+    // Early return if the user is not authenticated
+    let user = match auth.current_user {
+        Some(user) => user,
+        None => return Ok(Redirect::to("/signin").into_response()),
+    };
+
+    // Get entity types
+    let entity_types: Vec<String> = KnowledgeEntityType::variants()
+        .iter()
+        .map(|s| s.to_string())
+        .collect();
+
+    // Get the entity and validate ownership
+    let entity = User::get_and_validate_knowledge_entity(&id, &user.id, &state.surreal_db_client)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    let output = render_template(
+        "knowledge/edit_knowledge_entity_modal.html",
+        EntityData {
+            entity,
+            user,
+            entity_types,
+        },
+        state.templates,
+    )?;
+
+    Ok(output.into_response())
+}
+
+#[derive(Serialize)]
+pub struct EntityListData {
+    entities: Vec<KnowledgeEntity>,
+    user: User,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct PatchKnowledgeEntityParams {
+    pub id: String,
+    pub name: String,
+    pub entity_type: String,
+    pub description: String,
+}
+
+pub async fn patch_knowledge_entity(
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+    Form(form): Form<PatchKnowledgeEntityParams>,
+) -> Result<impl IntoResponse, HtmlError> {
+    // Early return if the user is not authenticated
+    let user = match auth.current_user {
+        Some(user) => user,
+        None => return Ok(Redirect::to("/signin").into_response()),
+    };
+
+    // Get the existing entity and validate that the user is allowed
+    User::get_and_validate_knowledge_entity(&form.id, &user.id, &state.surreal_db_client)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    let entity_type: KnowledgeEntityType = KnowledgeEntityType::from(form.entity_type);
+
+    // Update the entity
+    KnowledgeEntity::patch(
+        &form.id,
+        &form.name,
+        &form.description,
+        &entity_type,
+        &state.surreal_db_client,
+        &state.openai_client,
+    )
+    .await
+    .map_err(|e| HtmlError::new(AppError::from(e), state.templates.clone()))?;
+
+    // Get updated list of entities
+    let entities = User::get_knowledge_entities(&user.id, &state.surreal_db_client)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    // Render updated list
+    let output = render_template(
+        "knowledge/entity_list.html",
+        EntityListData { entities, user },
+        state.templates,
+    )?;
+
+    Ok(output.into_response())
+}
+
+pub async fn delete_knowledge_entity(
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+    Path(id): Path<String>,
+) -> Result<impl IntoResponse, HtmlError> {
+    // Early return if the user is not authenticated
+    let user = match auth.current_user {
+        Some(user) => user,
+        None => return Ok(Redirect::to("/signin").into_response()),
+    };
+
+    // Get the existing entity and validate that the user is allowed
+    User::get_and_validate_knowledge_entity(&id, &user.id, &state.surreal_db_client)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    // Delete the entity
+    delete_item::<KnowledgeEntity>(&state.surreal_db_client, &id)
+        .await
+        .map_err(|e| HtmlError::new(AppError::from(e), state.templates.clone()))?;
+
+    // Get updated list of entities
+    let entities = User::get_knowledge_entities(&user.id, &state.surreal_db_client)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    // Render updated list
+    let output = render_template(
+        "knowledge/entity_list.html",
+        EntityListData { entities, user },
+        state.templates,
+    )?;
+
+    Ok(output.into_response())
+}
+
+#[derive(Serialize)]
+pub struct RelationshipTableData {
+    entities: Vec<KnowledgeEntity>,
+    relationships: Vec<KnowledgeRelationship>,
+}
+
+pub async fn delete_knowledge_relationship(
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+    Path(id): Path<String>,
+) -> Result<impl IntoResponse, HtmlError> {
+    // Early return if the user is not authenticated
+    let user = match auth.current_user {
+        Some(user) => user,
+        None => return Ok(Redirect::to("/signin").into_response()),
+    };
+
+    // GOTTA ADD AUTH VALIDATION
+
+    KnowledgeRelationship::delete_relationship_by_id(&id, &state.surreal_db_client)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    let entities = User::get_knowledge_entities(&user.id, &state.surreal_db_client)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    let relationships = User::get_knowledge_relationships(&user.id, &state.surreal_db_client)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    // Render updated list
+    let output = render_template(
+        "knowledge/relationship_table.html",
+        RelationshipTableData {
+            entities,
+            relationships,
+        },
+        state.templates,
+    )?;
+
+    Ok(output.into_response())
+}
+
+#[derive(Deserialize)]
+pub struct SaveKnowledgeRelationshipInput {
+    pub in_: String,
+    pub out: String,
+    pub relationship_type: String,
+}
+
+pub async fn save_knowledge_relationship(
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+    Form(form): Form<SaveKnowledgeRelationshipInput>,
+) -> Result<impl IntoResponse, HtmlError> {
+    // Early return if the user is not authenticated
+    let user = match auth.current_user {
+        Some(user) => user,
+        None => return Ok(Redirect::to("/signin").into_response()),
+    };
+
+    // Construct relationship
+    let relationship = KnowledgeRelationship::new(
+        form.in_,
+        form.out,
+        user.id.clone(),
+        "manual".into(),
+        form.relationship_type,
+    );
+
+    relationship
+        .store_relationship(&state.surreal_db_client)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    let entities = User::get_knowledge_entities(&user.id, &state.surreal_db_client)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    let relationships = User::get_knowledge_relationships(&user.id, &state.surreal_db_client)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    // Render updated list
+    let output = render_template(
+        "knowledge/relationship_table.html",
+        RelationshipTableData {
+            entities,
+            relationships,
+        },
+        state.templates,
+    )?;
+
+    Ok(output.into_response())
+}

crates/html-router/src/routes/mod.rs

@@ -0,0 +1,91 @@
+use std::sync::Arc;
+
+use axum::response::Html;
+use minijinja_autoreload::AutoReloader;
+
+use common::error::{HtmlError, IntoHtmlError};
+
+pub mod account;
+pub mod admin_panel;
+pub mod chat;
+pub mod content;
+pub mod documentation;
+pub mod gdpr;
+pub mod index;
+pub mod ingress_form;
+pub mod knowledge;
+pub mod search_result;
+pub mod signin;
+pub mod signout;
+pub mod signup;
+
+pub trait PageData {
+    fn template_name() -> &'static str;
+}
+
+// Helper function for render_template
+pub fn render_template<T>(
+    template_name: &str,
+    context: T,
+    templates: Arc<AutoReloader>,
+) -> Result<Html<String>, HtmlError>
+where
+    T: serde::Serialize,
+{
+    let env = templates
+        .acquire_env()
+        .map_err(|e| e.with_template(templates.clone()))?;
+    let tmpl = env
+        .get_template(template_name)
+        .map_err(|e| e.with_template(templates.clone()))?;
+    let context = minijinja::Value::from_serialize(&context);
+    let output = tmpl
+        .render(context)
+        .map_err(|e| e.with_template(templates.clone()))?;
+    Ok(Html(output))
+}
+
+pub fn render_block<T>(
+    template_name: &str,
+    block: &str,
+    context: T,
+    templates: Arc<AutoReloader>,
+) -> Result<Html<String>, HtmlError>
+where
+    T: serde::Serialize,
+{
+    let env = templates
+        .acquire_env()
+        .map_err(|e| e.with_template(templates.clone()))?;
+    let tmpl = env
+        .get_template(template_name)
+        .map_err(|e| e.with_template(templates.clone()))?;
+
+    let context = minijinja::Value::from_serialize(&context);
+    let output = tmpl
+        .eval_to_state(context)
+        .map_err(|e| e.with_template(templates.clone()))?
+        .render_block(block)
+        .map_err(|e| e.with_template(templates.clone()))?;
+
+    Ok(output.into())
+}
+
+#[macro_export]
+macro_rules! page_data {
+    ($name:ident, $template_name:expr, {$($(#[$attr:meta])* $field:ident: $ty:ty),*$(,)?}) => {
+        use serde::{Serialize, Deserialize};
+        use $crate::routes::PageData;
+
+        #[derive(Debug, Deserialize, Serialize)]
+        pub struct $name {
+            $($(#[$attr])* pub $field: $ty),*
+        }
+
+        impl PageData for $name {
+            fn template_name() -> &'static str {
+                $template_name
+            }
+        }
+    };
+}

crates/html-router/src/routes/search_result.rs

@@ -0,0 +1,68 @@
+use axum::{
+    extract::{Query, State},
+    response::{IntoResponse, Redirect},
+};
+use axum_session_auth::AuthSession;
+use axum_session_surreal::SessionSurrealPool;
+use serde::{Deserialize, Serialize};
+use surrealdb::{engine::any::Any, Surreal};
+use tracing::info;
+
+use common::{error::HtmlError, storage::types::user::User};
+
+use crate::{html_state::HtmlState, routes::render_template};
+#[derive(Deserialize)]
+pub struct SearchParams {
+    query: String,
+}
+
+#[derive(Serialize)]
+pub struct AnswerData {
+    user_query: String,
+    answer_content: String,
+    answer_references: Vec<String>,
+}
+
+pub async fn search_result_handler(
+    State(state): State<HtmlState>,
+    Query(query): Query<SearchParams>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+) -> Result<impl IntoResponse, HtmlError> {
+    info!("Displaying search results");
+
+    let user = match auth.current_user {
+        Some(user) => user,
+        None => return Ok(Redirect::to("/signin").into_response()),
+    };
+
+    // let answer = get_answer_with_references(
+    //     &state.surreal_db_client,
+    //     &state.openai_client,
+    //     &query.query,
+    //     &user.id,
+    // )
+    // .await
+    // .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    let answer = "The Minne project is focused on simplifying knowledge management through features such as easy capture, smart analysis, and visualization of connections between ideas. It includes various functionalities like the Smart Analysis Feature, which provides content analysis and organization, and the Easy Capture Feature, which allows users to effortlessly capture and retrieve knowledge in various formats. Additionally, it offers tools like Knowledge Graph Visualization to enhance understanding and organization of knowledge. The project also emphasizes a user-friendly onboarding experience and mobile-friendly options for accessing its services.".to_string();
+
+    let references = vec![
+        "i81cd5be8-557c-4b2b-ba3a-4b8d28e74b9b".to_string(),
+        "5f72a724-d7a3-467d-8783-7cca6053ddc7".to_string(),
+        "ad106a1f-ccda-415e-9e87-c3a34e202624".to_string(),
+        "8797b57d-094d-4ee9-a3a7-c3195b246254".to_string(),
+        "69763f43-82e6-4cb5-ba3e-f6da13777dab".to_string(),
+    ];
+
+    let output = render_template(
+        "index/signed_in/search_response.html",
+        AnswerData {
+            user_query: query.query,
+            answer_content: answer,
+            answer_references: references,
+        },
+        state.templates,
+    )?;
+
+    Ok(output.into_response())
+}

crates/html-router/src/routes/signin.rs

@@ -0,0 +1,71 @@
+use axum::{
+    extract::State,
+    http::{StatusCode, Uri},
+    response::{Html, IntoResponse, Redirect},
+    Form,
+};
+use axum_htmx::{HxBoosted, HxRedirect};
+use axum_session_auth::AuthSession;
+use axum_session_surreal::SessionSurrealPool;
+use surrealdb::{engine::any::Any, Surreal};
+
+use common::{error::HtmlError, storage::types::user::User};
+
+use crate::{html_state::HtmlState, page_data};
+
+use super::{render_block, render_template};
+
+#[derive(Deserialize, Serialize)]
+pub struct SignupParams {
+    pub email: String,
+    pub password: String,
+    pub remember_me: Option<String>,
+}
+
+page_data!(ShowSignInForm, "auth/signin_form.html", {});
+
+pub async fn show_signin_form(
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+    HxBoosted(boosted): HxBoosted,
+) -> Result<impl IntoResponse, HtmlError> {
+    if auth.is_authenticated() {
+        return Ok(Redirect::to("/").into_response());
+    }
+    let output = match boosted {
+        true => render_block(
+            ShowSignInForm::template_name(),
+            "body",
+            ShowSignInForm {},
+            state.templates.clone(),
+        )?,
+        false => render_template(
+            ShowSignInForm::template_name(),
+            ShowSignInForm {},
+            state.templates.clone(),
+        )?,
+    };
+
+    Ok(output.into_response())
+}
+
+pub async fn authenticate_user(
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+    Form(form): Form<SignupParams>,
+) -> Result<impl IntoResponse, HtmlError> {
+    let user = match User::authenticate(form.email, form.password, &state.surreal_db_client).await {
+        Ok(user) => user,
+        Err(_) => {
+            return Ok(Html("<p>Incorrect email or password </p>").into_response());
+        }
+    };
+
+    auth.login_user(user.id);
+
+    if form.remember_me.is_some_and(|string| string == *"on") {
+        auth.remember_user(true);
+    }
+
+    Ok((HxRedirect::from(Uri::from_static("/")), StatusCode::OK).into_response())
+}

crates/html-router/src/routes/signout.rs

@@ -0,0 +1,18 @@
+use axum::response::{IntoResponse, Redirect};
+use axum_session_auth::AuthSession;
+use axum_session_surreal::SessionSurrealPool;
+use surrealdb::{engine::any::Any, Surreal};
+
+use common::{error::ApiError, storage::types::user::User};
+
+pub async fn sign_out_user(
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+) -> Result<impl IntoResponse, ApiError> {
+    if !auth.is_authenticated() {
+        return Ok(Redirect::to("/").into_response());
+    }
+
+    auth.logout_user();
+
+    Ok(Redirect::to("/").into_response())
+}

crates/html-router/src/routes/signup.rs

@@ -0,0 +1,65 @@
+use axum::{
+    extract::State,
+    http::{StatusCode, Uri},
+    response::{Html, IntoResponse, Redirect},
+    Form,
+};
+use axum_htmx::{HxBoosted, HxRedirect};
+use axum_session_auth::AuthSession;
+use axum_session_surreal::SessionSurrealPool;
+use serde::{Deserialize, Serialize};
+use surrealdb::{engine::any::Any, Surreal};
+
+use common::{error::HtmlError, storage::types::user::User};
+
+use crate::html_state::HtmlState;
+
+use super::{render_block, render_template};
+
+#[derive(Deserialize, Serialize)]
+pub struct SignupParams {
+    pub email: String,
+    pub password: String,
+    pub timezone: String,
+}
+
+pub async fn show_signup_form(
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+    HxBoosted(boosted): HxBoosted,
+) -> Result<impl IntoResponse, HtmlError> {
+    if auth.is_authenticated() {
+        return Ok(Redirect::to("/").into_response());
+    }
+    let output = match boosted {
+        true => render_block("auth/signup_form.html", "body", {}, state.templates.clone())?,
+        false => render_template("auth/signup_form.html", {}, state.templates.clone())?,
+    };
+
+    Ok(output.into_response())
+}
+
+pub async fn process_signup_and_show_verification(
+    State(state): State<HtmlState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+    Form(form): Form<SignupParams>,
+) -> Result<impl IntoResponse, HtmlError> {
+    let user = match User::create_new(
+        form.email,
+        form.password,
+        &state.surreal_db_client,
+        form.timezone,
+    )
+    .await
+    {
+        Ok(user) => user,
+        Err(e) => {
+            tracing::error!("{:?}", e);
+            return Ok(Html(format!("<p>{}</p>", e)).into_response());
+        }
+    };
+
+    auth.login_user(user.id);
+
+    Ok((HxRedirect::from(Uri::from_static("/")), StatusCode::OK).into_response())
+}