diff --git a/README.md b/README.md
index dce6f98..a6261f5 100644
--- a/README.md
+++ b/README.md
@@ -31,8 +31,10 @@
 - [More Detailed Configurations](#more-detailed-configurations)
   - [DB configuration](#db-configuration)
   - [GraphRAG configuration](#graphrag-configuration)
-  - [Chat configuration](#chat-configuration)
+  - [Chat History Configuration](#chat-history-configuration)
   - [LLM provider configuration](#llm-provider-configuration)
+    - [Supported parameters](#supported-parameters)
+    - [Provider examples](#provider-examples)
     - [OpenAI](#openai)
     - [Google GenAI](#google-genai)
     - [GCP VertexAI](#gcp-vertexai)
@@ -53,7 +55,7 @@
 ---
 
 ## Releases
-* **2/28/2025**: GraphRAG v1.2.0 released. Added Admin UI for graph initialization, document ingestion, and knowledge graph rebuild, along with many other improvements and bug fixes. See [release notes](https://github.com/tigergraph/graphrag/releases/tag/v1.2.0) for details.
+* **2/28/2026**: GraphRAG v1.2.0 released. Added Admin UI for graph initialization, document ingestion, and knowledge graph rebuild, along with many other improvements and bug fixes. See [release notes](https://github.com/tigergraph/graphrag/releases/tag/v1.2.0) for details.
 * **9/22/2025**: GraphRAG is available now officially v1.1 (v1.1.0). AWS Bedrock support is completed with BDA integration for multimodal document ingestion. See [release notes](https://github.com/tigergraph/graphrag/releases/tag/v1.1.0) for details.
 * **6/18/2025**: GraphRAG is available now officially v1.0 (v1.0.0). TigerGraph database is the only graph and vector storagge supported.
 Please see [Release Notes](https://docs.tigergraph.com/tg-graphrag/current/release-notes/) for details.
@@ -103,7 +105,7 @@ Organizing the data as a knowledge graph allows a chatbot to access accurate, fa
 ### Quick Start
 
 #### Use TigerGraph Docker-Based Instance
-Set your LLM Provider (supported `openai` or `gemini`) api key as environment varabiel LLM_API_KEY and use the following command for a one-step quick deployment with TigerGraph Community Edition and default configurations:
+Set your LLM Provider (supported `openai` or `gemini`) api key as environment variable LLM_API_KEY and use the following command for a one-step quick deployment with TigerGraph Community Edition and default configurations:
 ```
 curl -k https://raw.githubusercontent.com/tigergraph/graphrag/refs/heads/main/docs/tutorials/setup_graphrag.sh | bash
 ```
@@ -198,10 +200,10 @@ Run command `docker compose down` and wait for all the service containers to sto
 
 If you prefer to start a TigerGraph Community Edition instance without a license key, please make sure the container can be accessed from the GraphRAG containers by add `--network graphrag_default`:
 ```
-docker run -d -p 14240:14240 --name tigergraph --ulimit nofile=1000000:1000000 --init --network graphrag_default -t tigergraph/community:4.2.1
+docker run -d -p 14240:14240 --name tigergraph --ulimit nofile=1000000:1000000 --init --network graphrag_default -t tigergraph/community:4.2.2
 ```
 
-> Use **tigergraph/tigergraph:4.2.1** if Enterprise Edition is preferred.
+> Use **tigergraph/tigergraph:4.2.2** if Enterprise Edition is preferred.
 > Setting up **DNS** or `/etc/hosts` properly is an alternative solution to ensure contains can connect to each other.
 > Or modify`hostname` in `db_config` section of `configs/server_config.json` and replace `http://tigergraph` to your tigergraph container IP address, e.g., `http://172.19.0.2`. 
 
@@ -419,6 +421,8 @@ Copy the below into `configs/server_config.json` and edit the `hostname` and `ge
         "hostname": "http://tigergraph",
         "restppPort": "9000",
         "gsPort": "14240",
+        "username": "tigergraph",
+        "password": "tigergraph",
         "getToken": false,
         "default_timeout": 300,
         "default_mem_threshold": 5000,
@@ -427,23 +431,65 @@ Copy the below into `configs/server_config.json` and edit the `hostname` and `ge
 }
 ```
 
+| Parameter | Type | Default | Description |
+| --- | --- | --- | --- |
+| `hostname` | string | `"http://tigergraph"` | TigerGraph server URL. |
+| `restppPort` | string | `"9000"` | RESTPP port for TigerGraph API requests. |
+| `gsPort` | string | `"14240"` | GSQL port for TigerGraph admin operations. |
+| `username` | string | `"tigergraph"` | TigerGraph database username. |
+| `password` | string | `"tigergraph"` | TigerGraph database password. |
+| `getToken` | bool | `false` | Set to `true` if token authentication is enabled on TigerGraph. |
+| `graphname` | string | `""` | Default graph name. Usually left empty (selected at runtime). |
+| `apiToken` | string | `""` | Pre-generated API token. If set, token-based auth is used instead of username/password. |
+| `default_timeout` | int | `300` | Default query timeout in seconds. |
+| `default_mem_threshold` | int | `5000` | Memory threshold (MB) for query execution. |
+| `default_thread_limit` | int | `8` | Max threads for query execution. |
+
 ### GraphRAG configuration
 Copy the below code into `configs/server_config.json`. You shouldn’t need to change anything unless you change the port of the chat history service in the Docker Compose file.
 
-`reuse_embedding` to `true` will skip re-generating the embedding if it already exists.
-`ecc` and `chat_history_api` are the addresses of internal components of GraphRAG.If you use the Docker Compose file as is, you don’t need to change them.
-
 ```json
 {
     "graphrag_config": {
         "reuse_embedding": false,
-        "ecc": "http://eventual-consistency-service:8001",
-        "chat_history_api": "http://chat-history:8002"
+        "ecc": "http://graphrag-ecc:8001",
+        "chat_history_api": "http://chat-history:8002",
+        "chunker": "semantic",
+        "extractor": "llm",
+        "top_k": 5,
+        "num_hops": 2
     }
 }
 ```
 
-### Chat configuration
+| Parameter | Type | Default | Description |
+| --- | --- | --- | --- |
+| `reuse_embedding` | bool | `true` | Reuse existing embeddings instead of regenerating them. |
+| `ecc` | string | `"http://graphrag-ecc:8001"` | URL of the knowledge graph build service. No change needed when using the provided Docker Compose file. |
+| `chat_history_api` | string | `"http://chat-history:8002"` | URL of the chat history service. No change needed when using the provided Docker Compose file. |
+| `chunker` | string | `"semantic"` | Default document chunker. Options: `semantic`, `character`, `regex`, `markdown`, `html`, `recursive`. |
+| `extractor` | string | `"llm"` | Entity extraction method. Options: `llm`, `graphrag`. |
+| `chunker_config` | object | `{}` | Chunker-specific settings. For `character`/`markdown`/`recursive`: `chunk_size`, `overlap_size`. For `semantic`: `method`, `threshold`. For `regex`: `pattern`. |
+| `top_k` | int | `5` | Number of top similar results to retrieve during search. |
+| `num_hops` | int | `2` | Number of graph hops to traverse when expanding retrieved results. |
+| `num_seen_min` | int | `2` | Minimum occurrence threshold for a node to be included in search results. |
+| `community_level` | int | `2` | Community hierarchy level used for community search. |
+| `chunk_only` | bool | `true` | If true, hybrid search only retrieves document chunks (not entities). |
+| `doc_only` | bool | `false` | If true, hybrid search retrieves whole documents instead of chunks. |
+| `with_chunk` | bool | `true` | If true, community search also includes document chunks in results. |
+| `doc_process_switch` | bool | `true` | Enable/disable document processing during knowledge graph build. |
+| `entity_extraction_switch` | bool | same as `doc_process_switch` | Enable/disable entity extraction during knowledge graph build. |
+| `community_detection_switch` | bool | same as `entity_extraction_switch` | Enable/disable community detection during knowledge graph build. |
+| `load_batch_size` | int | `500` | Batch size for document loading. |
+| `upsert_delay` | int | `0` | Delay in seconds between loading batches. |
+| `default_concurrency` | int | `10` | Base concurrency level for parallel processing. Configurable per graph. |
+| `process_interval_seconds` | int | `300` | Interval (seconds) for background consistency processing. |
+| `cleanup_interval_seconds` | int | `300` | Interval (seconds) for background cleanup. |
+| `checker_batch_size` | int | `100` | Batch size for background consistency checking. |
+| `enable_consistency_checker` | bool | `false` | Enable the background consistency checker. |
+| `graph_names` | list | `[]` | Graphs to monitor when consistency checker is enabled. |
+
+### Chat History Configuration
 Copy the below code into `configs/server_config.json`. You shouldn’t need to change anything unless you change the port of the chat history service in the Docker Compose file.
 
 ```json
@@ -464,6 +510,99 @@ Copy the below code into `configs/server_config.json`. You shouldn’t need to c
 ### LLM provider configuration
 In the `llm_config` section of `configs/server_config.json` file, copy JSON config template from below for your LLM provider, and fill out the appropriate fields. Only one provider is needed.
 
+#### Structure overview
+
+```json
+{
+  "llm_config": {
+    "authentication_configuration": {
+      "OPENAI_API_KEY": "sk-..."
+    },
+    "completion_service": {
+      "llm_service": "openai",
+      "llm_model": "gpt-4.1-mini",
+      "model_kwargs": { "temperature": 0 },
+      "prompt_path": "./common/prompts/openai_gpt4/"
+    },
+    "embedding_service": {
+      "embedding_model_service": "openai",
+      "model_name": "text-embedding-3-small"
+    },
+    "chat_service": {
+      "llm_model": "gpt-4.1"
+    },
+    "multimodal_service": {
+      "llm_service": "openai",
+      "llm_model": "gpt-4o"
+    }
+  }
+}
+```
+
+- `authentication_configuration`: Shared credentials for all services. Service-level keys take precedence over top-level keys.
+- `completion_service` **(required)**: LLM for knowledge graph building and query generation.
+- `embedding_service` **(required)**: Text embedding model for document indexing.
+- `chat_service` *(optional)*: Chatbot LLM override. Missing keys are inherited from `completion_service`. Configurable per graph.
+- `multimodal_service` *(optional)*: Vision/image model for document ingestion.
+
+#### Supported parameters
+
+**Top-level `llm_config` parameters:**
+
+| Parameter | Type | Default | Description |
+| --- | --- | --- | --- |
+| `authentication_configuration` | object | — | Shared authentication credentials for all services. Service-level values take precedence. |
+| `token_limit` | int | — | Maximum token count for retrieved context. Inherited by all services if not set at service level. `0` or omitted means unlimited. |
+
+**`completion_service` parameters:**
+
+| Parameter | Type | Required | Default | Description |
+| --- | --- | --- | --- | --- |
+| `llm_service` | string | **Yes** | — | LLM provider. Options: `openai`, `azure`, `vertexai`, `genai`, `bedrock`, `sagemaker`, `groq`, `ollama`, `huggingface`, `watsonx`. |
+| `llm_model` | string | **Yes** | — | Model name for knowledge graph building and query generation (e.g., `gpt-4.1-mini`). |
+| `authentication_configuration` | object | No | inherited from top-level | Service-specific auth credentials. Overrides top-level values. |
+| `model_kwargs` | object | No | `{}` | Additional model parameters (e.g., `{"temperature": 0}`). |
+| `prompt_path` | string | No | `"./common/prompts/openai_gpt4/"` | Path to prompt template files. |
+| `base_url` | string | No | — | Custom API endpoint URL. |
+| `token_limit` | int | No | inherited from top-level | Max token count for retrieved context sent to the LLM. `0` or omitted means unlimited. |
+
+**`embedding_service` parameters:**
+
+| Parameter | Type | Required | Default | Description |
+| --- | --- | --- | --- | --- |
+| `embedding_model_service` | string | **Yes** | — | Embedding provider. Options: `openai`, `azure`, `vertexai`, `genai`, `bedrock`, `ollama`. |
+| `model_name` | string | **Yes** | — | Embedding model name (e.g., `text-embedding-3-small`). |
+| `dimensions` | int | No | `1536` | Embedding vector dimensions. |
+| `authentication_configuration` | object | No | inherited from top-level | Service-specific auth credentials. Overrides top-level values. |
+
+**`chat_service` parameters (optional):**
+
+Chatbot LLM override. If not configured, inherits from `completion_service`. Configurable per graph via the UI.
+
+| Parameter | Type | Required | Default | Description |
+| --- | --- | --- | --- | --- |
+| `llm_service` | string | No | same as completion | LLM provider for the chatbot. |
+| `llm_model` | string | No | same as completion | Model name for the chatbot. |
+| `authentication_configuration` | object | No | inherited from completion | Auth credentials. Service-level values take precedence. |
+| `model_kwargs` | object | No | inherited from completion | Additional model parameters (e.g., `{"temperature": 0}`). |
+| `prompt_path` | string | No | inherited from completion | Path to prompt template files. |
+| `base_url` | string | No | inherited from completion | Custom API endpoint URL. |
+| `token_limit` | int | No | inherited from completion | Max token count for retrieved context sent to the chatbot LLM. `0` or omitted means unlimited. |
+
+**`multimodal_service` parameters (optional):**
+
+Vision model for image processing during document ingestion. If not configured, inherits from `completion_service` with a default vision model derived per provider.
+
+| Parameter | Type | Required | Default | Description |
+| --- | --- | --- | --- | --- |
+| `llm_service` | string | No | inherited from completion | Multimodal LLM provider. |
+| `llm_model` | string | No | auto-derived per provider | Vision model name (e.g., `gpt-4o`). |
+| `authentication_configuration` | object | No | inherited from completion | Service-specific auth credentials. Overrides top-level values. |
+| `model_kwargs` | object | No | inherited from completion | Additional model parameters. |
+| `prompt_path` | string | No | inherited from completion | Path to prompt template files. |
+
+#### Provider examples
+
 #### OpenAI
 In addition to the `OPENAI_API_KEY`, `llm_model` and `model_name` can be edited to match your specific configuration details.
 
diff --git a/common/config.py b/common/config.py
index 2b58581..371e303 100644
--- a/common/config.py
+++ b/common/config.py
@@ -13,9 +13,18 @@
 # limitations under the License.
 
 import json
+import logging
 import os
+import re
+import threading
 
 from fastapi.security import HTTPBasic
+
+logger = logging.getLogger(__name__)
+
+# Lock for all reads/writes to SERVER_CONFIG to prevent concurrent modifications
+# from different endpoints (LLM, DB, GraphRAG config saves) from overwriting each other.
+_config_file_lock = threading.Lock()
 from pyTigerGraph import TigerGraphConnection
 
 from common.embeddings.embedding_services import (
@@ -40,7 +49,6 @@
     OpenAI,
     IBMWatsonX
 )
-from common.logs.logwriter import LogWriter
 from common.session import SessionHandler
 from common.status import StatusManager
 
@@ -51,6 +59,202 @@
 
 # Configs
 SERVER_CONFIG = os.getenv("SERVER_CONFIG", "configs/server_config.json")
+
+
+_VALID_GRAPHNAME_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
+
+
+def validate_graphname(graphname: str) -> str:
+    """Validate graphname to prevent path traversal.
+
+    Raises ValueError if graphname contains path separators or other unsafe characters.
+    Returns the graphname unchanged if valid.
+    """
+    if not graphname:
+        return graphname
+    if not _VALID_GRAPHNAME_RE.match(graphname):
+        raise ValueError(f"Invalid graph name: {graphname!r}")
+    return graphname
+
+
+def _load_graph_config(graphname):
+    """Load entire graph-specific server config overrides, or empty dict if none exist."""
+    if not graphname:
+        return {}
+    validate_graphname(graphname)
+    graph_path = f"configs/graph_configs/{graphname}/server_config.json"
+    if not os.path.exists(graph_path):
+        return {}
+    with open(graph_path, "r") as f:
+        return json.load(f)
+
+
+def _load_graph_llm_config(graphname):
+    """Load graph-specific llm_config overrides, or empty dict if none exist."""
+    return _load_graph_config(graphname).get("llm_config", {})
+
+
+def _resolve_service_config(base_config, override=None):
+    """
+    Merge a service override on top of a base config (typically completion_service).
+
+    - Starts with base_config as the foundation
+    - Overlays override keys on top (if provided)
+    - authentication_configuration: override keys take precedence,
+      missing keys fall back to base auth
+    """
+    result = base_config.copy()
+
+    if not override:
+        return result
+
+    for key, value in override.items():
+        if key == "authentication_configuration":
+            continue  # Handle separately below
+        result[key] = value
+
+    if "authentication_configuration" in override:
+        merged_auth = result.get("authentication_configuration", {}).copy()
+        merged_auth.update(override["authentication_configuration"])
+        result["authentication_configuration"] = merged_auth
+    # else: keep base's auth
+
+    return result
+
+
+def get_completion_config(graphname=None):
+    """
+    Return completion_service config for the given graph.
+
+    Resolution: merge graph-specific completion_service overrides on top of
+    global completion_service. Graph configs only store overrides, so unchanged
+    fields always inherit the latest global values.
+    """
+    graph_llm = _load_graph_llm_config(graphname)
+    override = graph_llm.get("completion_service")
+    if override:
+        logger.debug(f"[get_completion_config] graph={graphname} using graph-specific overrides")
+    result = _resolve_service_config(llm_config["completion_service"], override)
+
+    if graphname:
+        result["graphname"] = graphname
+
+    return result
+
+
+DEFAULT_MULTIMODAL_MODELS = {
+    "openai": "gpt-4o-mini",
+    "azure": "gpt-4o-mini",
+    "genai": "gemini-3.5-flash",
+    "vertexai": "gemini-3.5-flash",
+    "bedrock": "us.anthropic.claude-sonnet-4-5-20250929-v1:0",
+}
+
+
+def get_chat_config(graphname=None):
+    """
+    Return the chatbot LLM config for the given graph.
+
+    Resolution chain:
+      1. Start with global completion_service
+      2. Merge graph-specific completion_service overrides (shared base for all services)
+      3. Merge chat_service overrides (graph-specific > global > none)
+
+    This ensures graph-level completion_service changes (e.g. prompt_path)
+    propagate to the chatbot config as well.
+    """
+    graph_llm = _load_graph_llm_config(graphname)
+
+    # Build per-graph base: global completion + graph completion overrides
+    base = _resolve_service_config(
+        llm_config["completion_service"],
+        graph_llm.get("completion_service"),
+    )
+
+    # Find chat override: graph-specific > global > None
+    chat_override = graph_llm.get("chat_service")
+    if chat_override:
+        logger.debug(f"[get_chat_config] graph={graphname} using graph-specific chat_service")
+    elif "chat_service" in llm_config:
+        chat_override = llm_config["chat_service"]
+        logger.debug(f"[get_chat_config] graph={graphname} using global chat_service")
+    else:
+        logger.debug(f"[get_chat_config] graph={graphname} falling back to completion_service")
+
+    result = _resolve_service_config(base, chat_override)
+
+    if graphname:
+        result["graphname"] = graphname
+
+    return result
+
+
+def _apply_default_multimodal_model(override, provider):
+    """Apply default vision model if llm_model is not explicitly set."""
+    if override and "llm_model" not in override:
+        default_model = DEFAULT_MULTIMODAL_MODELS.get(provider)
+        if default_model:
+            return {**override, "llm_model": default_model}
+        return override
+    if not override:
+        default_model = DEFAULT_MULTIMODAL_MODELS.get(provider)
+        if default_model:
+            return {"llm_model": default_model}
+        return None
+    return override
+
+
+def get_multimodal_config(graphname=None):
+    """
+    Return the multimodal/vision config for the given graph.
+
+    Resolution chain:
+      1. Start with global completion_service
+      2. Merge graph-specific completion_service overrides (shared base)
+      3. Merge multimodal_service overrides (graph-specific > global > default model)
+
+    Returns the merged config, or None if the provider doesn't support vision.
+    """
+    graph_llm = _load_graph_llm_config(graphname)
+
+    # Build per-graph base: global completion + graph completion overrides
+    base = _resolve_service_config(
+        llm_config["completion_service"],
+        graph_llm.get("completion_service"),
+    )
+
+    # Find multimodal override: graph-specific > global > None
+    mm_override = graph_llm.get("multimodal_service")
+    if mm_override is None and "multimodal_service" in llm_config:
+        mm_override = llm_config["multimodal_service"]
+
+    provider = (mm_override or {}).get("llm_service", base.get("llm_service", "")).lower()
+    mm_override = _apply_default_multimodal_model(mm_override, provider)
+
+    if mm_override is None:
+        return None
+
+    return _resolve_service_config(base, mm_override)
+
+
+def get_graphrag_config(graphname=None):
+    """
+    Return graphrag_config for the given graph.
+
+    Resolution: merge graph-specific graphrag_config overrides on top of
+    global graphrag_config. Graph configs only store overrides, so unchanged
+    fields always inherit the latest global values.
+    """
+    graph_cfg = _load_graph_config(graphname)
+    override = graph_cfg.get("graphrag_config")
+    if not override:
+        return graphrag_config
+    # Merge: global as base, graph overrides on top (simple dict merge, no auth logic)
+    result = graphrag_config.copy()
+    result.update(override)
+    return result
+
+
 PATH_PREFIX = os.getenv("PATH_PREFIX", "")
 PRODUCTION = os.getenv("PRODUCTION", "false").lower() == "true"
 
@@ -83,64 +287,61 @@
 if llm_config is None:
     raise Exception("llm_config is not found in SERVER_CONFIG")
 
-completion_config = llm_config.get("completion_service")
-if completion_config is None:
+# Inject authentication_configuration into service configs so they have everything they need.
+# Rule: service-level (lower) auth keys take precedence; missing keys fall back to top-level (upper).
+if "authentication_configuration" in llm_config:
+    for svc_key in ["completion_service", "embedding_service", "multimodal_service", "chat_service"]:
+        if svc_key in llm_config:
+            svc = llm_config[svc_key]
+            if "authentication_configuration" not in svc:
+                svc["authentication_configuration"] = llm_config["authentication_configuration"].copy()
+            else:
+                # Merge: top-level as base, service-level on top (service-level wins)
+                merged = llm_config["authentication_configuration"].copy()
+                merged.update(svc["authentication_configuration"])
+                svc["authentication_configuration"] = merged
+
+_comp = llm_config.get("completion_service")
+if _comp is None:
     raise Exception("completion_service is not found in llm_config")
-if "llm_service" not in completion_config:
+if "llm_service" not in _comp:
     raise Exception("llm_service is not found in completion_service")
-if "llm_model" not in completion_config:
+if "llm_model" not in _comp:
     raise Exception("llm_model is not found in completion_service")
-embedding_config = llm_config.get("embedding_service")
-if embedding_config is None:
+
+# Log which model will be used for chatbot and ECC/GraphRAG
+if "chat_service" in llm_config:
+    chat_svc = llm_config["chat_service"]
+    logger.info(f"[CHATBOT] Using chat_service: {chat_svc.get('llm_model', 'N/A')} (Provider: {chat_svc.get('llm_service', _comp['llm_service'])})")
+    logger.info(f"[ECC] Using completion_service: {_comp['llm_model']} (Provider: {_comp['llm_service']})")
+else:
+    logger.info(f"[CHATBOT] Using completion_service llm_model: {_comp['llm_model']} (Provider: {_comp['llm_service']})")
+    logger.info(f"[ECC] Using completion_service: {_comp['llm_model']} (Provider: {_comp['llm_service']})")
+
+_emb = llm_config.get("embedding_service")
+if _emb is None:
     raise Exception("embedding_service is not found in llm_config")
-if "embedding_model_service" not in embedding_config:
+if "embedding_model_service" not in _emb:
     raise Exception("embedding_model_service is not found in embedding_service")
-if "model_name" not in embedding_config:
+if "model_name" not in _emb:
     raise Exception("model_name is not found in embedding_service")
-embedding_dimension = embedding_config.get("dimensions", 1536)
+embedding_dimension = _emb.get("dimensions", 1536)
+
+# Log which embedding model will be used
+logger.info(f"[EMBEDDING] Using model: {_emb.get('model_name', 'N/A')} (Provider: {_emb.get('embedding_model_service', 'N/A')})")
 
 # Get context window size from llm_config
 # <=0 means unlimited tokens (no truncation), otherwise use the specified limit
 if "token_limit" in llm_config:
-    if "token_limit" not in completion_config:
-        completion_config["token_limit"] = llm_config["token_limit"]
-    if "token_limit" not in embedding_config:
-        embedding_config["token_limit"] = llm_config["token_limit"]
-
-# Get multimodal_service config (optional, for vision/image tasks)
-multimodal_config = llm_config.get("multimodal_service")
-
-# Merge shared authentication configuration from llm_config level into service configs
-# Services can still override by defining their own authentication_configuration
-shared_auth = llm_config.get("authentication_configuration", {})
-if shared_auth:
-    # Merge into embedding_config (service-specific auth takes precedence)
-    if "authentication_configuration" not in embedding_config:
-        embedding_config["authentication_configuration"] = shared_auth.copy()
-    else:
-        # Merge shared auth with service-specific auth (service-specific takes precedence)
-        merged_embedding_auth = shared_auth.copy()
-        merged_embedding_auth.update(embedding_config["authentication_configuration"])
-        embedding_config["authentication_configuration"] = merged_embedding_auth
-    
-    # Merge into completion_config (service-specific auth takes precedence)
-    if "authentication_configuration" not in completion_config:
-        completion_config["authentication_configuration"] = shared_auth.copy()
-    else:
-        # Merge shared auth with service-specific auth (service-specific takes precedence)
-        merged_completion_auth = shared_auth.copy()
-        merged_completion_auth.update(completion_config["authentication_configuration"])
-        completion_config["authentication_configuration"] = merged_completion_auth
-    
-    # Merge into multimodal_config if it exists (service-specific auth takes precedence)
-    if multimodal_config:
-        if "authentication_configuration" not in multimodal_config:
-            multimodal_config["authentication_configuration"] = shared_auth.copy()
-        else:
-            # Merge shared auth with service-specific auth (service-specific takes precedence)
-            merged_multimodal_auth = shared_auth.copy()
-            merged_multimodal_auth.update(multimodal_config["authentication_configuration"])
-            multimodal_config["authentication_configuration"] = merged_multimodal_auth
+    if "token_limit" not in _comp:
+        _comp["token_limit"] = llm_config["token_limit"]
+    if "token_limit" not in _emb:
+        _emb["token_limit"] = llm_config["token_limit"]
+
+# Log multimodal_service config (optional, for vision/image tasks).
+_mm_config = get_multimodal_config()
+if _mm_config:
+    logger.info(f"[MULTIMODAL] Using model: {_mm_config.get('llm_model', 'N/A')} (Provider: {_mm_config.get('llm_service', 'N/A')})")
 
 if graphrag_config is None:
     graphrag_config = {"reuse_embedding": True}
@@ -175,81 +376,38 @@
 else:
     raise Exception("Embedding service not implemented")
 
-def get_llm_service(llm_config) -> LLM_Model:
-    if llm_config["completion_service"]["llm_service"].lower() == "openai":
-        return OpenAI(llm_config["completion_service"])
-    elif llm_config["completion_service"]["llm_service"].lower() == "azure":
-        return AzureOpenAI(llm_config["completion_service"])
-    elif llm_config["completion_service"]["llm_service"].lower() == "sagemaker":
-        return AWS_SageMaker_Endpoint(llm_config["completion_service"])
-    elif llm_config["completion_service"]["llm_service"].lower() == "vertexai":
-        return GoogleVertexAI(llm_config["completion_service"])
-    elif llm_config["completion_service"]["llm_service"].lower() == "genai":
-        return GoogleGenAI(llm_config["completion_service"])
-    elif llm_config["completion_service"]["llm_service"].lower() == "bedrock":
-        return AWSBedrock(llm_config["completion_service"])
-    elif llm_config["completion_service"]["llm_service"].lower() == "groq":
-        return Groq(llm_config["completion_service"])
-    elif llm_config["completion_service"]["llm_service"].lower() == "ollama":
-        return Ollama(llm_config["completion_service"])
-    elif llm_config["completion_service"]["llm_service"].lower() == "huggingface":
-        return HuggingFaceEndpoint(llm_config["completion_service"])
-    elif llm_config["completion_service"]["llm_service"].lower() == "watsonx":
-        return IBMWatsonX(llm_config["completion_service"])
-    else:
-        raise Exception("LLM Completion Service Not Supported")
-
-DEFAULT_MULTIMODAL_MODELS = {
-    "openai": "gpt-4o-mini",
-    "azure": "gpt-4o-mini",
-    "genai": "gemini-3.5-flash",
-    "vertexai": "gemini-3.5-flash",
-    "bedrock": "us.anthropic.claude-sonnet-4-5-20250929-v1:0",
-}
-
-def get_multimodal_service() -> LLM_Model:
-    """
-    Get the multimodal/vision LLM service for image description tasks.
-    Priority:
-      1. Explicit multimodal_service config
-      2. Auto-derived from completion_service with a default vision model
-    Currently supports: OpenAI, Azure, GenAI, VertexAI, Bedrock
+def get_llm_service(service_config: dict) -> LLM_Model:
     """
-    config_copy = completion_config.copy()
-
-    if multimodal_config:
-        config_copy.update(multimodal_config)
+    Instantiate an LLM provider from a flat service config dict.
 
-    service_type = config_copy.get("llm_service", "").lower()
-
-    if not multimodal_config or "llm_model" not in multimodal_config:
-        default_model = DEFAULT_MULTIMODAL_MODELS.get(service_type)
-        if default_model:
-            config_copy["llm_model"] = default_model
-            LogWriter.info(
-                f"Using default vision model '{default_model}' "
-                f"for provider '{service_type}'"
-            )
-
-    if "prompt_path" not in config_copy:
-        config_copy["prompt_path"] = "./common/prompts/openai_gpt4/"
-
-    if service_type == "openai":
-        return OpenAI(config_copy)
-    elif service_type == "azure":
-        return AzureOpenAI(config_copy)
-    elif service_type == "genai":
-        return GoogleGenAI(config_copy)
-    elif service_type == "vertexai":
-        return GoogleVertexAI(config_copy)
-    elif service_type == "bedrock":
-        return AWSBedrock(config_copy)
+    The config must contain ``llm_service`` at the top level.
+    Use ``get_completion_config()`` or ``get_chat_config()`` to obtain
+    the appropriate config for ECC or chatbot callers respectively.
+    """
+    service_name = service_config["llm_service"].lower()
+    if service_name == "openai":
+        return OpenAI(service_config)
+    elif service_name == "azure":
+        return AzureOpenAI(service_config)
+    elif service_name == "sagemaker":
+        return AWS_SageMaker_Endpoint(service_config)
+    elif service_name == "vertexai":
+        return GoogleVertexAI(service_config)
+    elif service_name == "genai":
+        return GoogleGenAI(service_config)
+    elif service_name == "bedrock":
+        return AWSBedrock(service_config)
+    elif service_name == "groq":
+        return Groq(service_config)
+    elif service_name == "ollama":
+        return Ollama(service_config)
+    elif service_name == "huggingface":
+        return HuggingFaceEndpoint(service_config)
+    elif service_name == "watsonx":
+        return IBMWatsonX(service_config)
     else:
-        LogWriter.warning(
-            f"Multimodal/vision not supported for provider '{service_type}'. "
-            "Image descriptions will be skipped."
-        )
-        return None
+        raise Exception(f"LLM service '{service_name}' not supported")
+
 
 if os.getenv("INIT_EMBED_STORE", "true") == "true":
     conn = TigerGraphConnection(
@@ -270,3 +428,203 @@ def get_multimodal_service() -> LLM_Model:
         support_ai_instance=True,
     )
     service_status["embedding_store"] = {"status": "ok", "error": None}
+
+
+def reload_llm_config(new_llm_config: dict = None):
+    """
+    Reload LLM configuration and reinitialize services.
+    
+    Args:
+        new_llm_config: If provided, saves this config to file first. 
+                       If None, just reloads from existing file.
+    
+    Returns:
+        dict: Status of reload operation
+    """
+    global llm_config, embedding_service
+
+    try:
+        with _config_file_lock:
+            # If new config provided, save it first
+            if new_llm_config is not None:
+                with open(SERVER_CONFIG, "r") as f:
+                    server_config = json.load(f)
+
+                server_config["llm_config"] = new_llm_config
+
+                temp_file = f"{SERVER_CONFIG}.tmp"
+                with open(temp_file, "w") as f:
+                    json.dump(server_config, f, indent=2)
+                os.replace(temp_file, SERVER_CONFIG)
+
+            # Read/reload from file
+            with open(SERVER_CONFIG, "r") as f:
+                server_config = json.load(f)
+
+        # Validate before updating
+        new_llm_config = server_config.get("llm_config")
+        if new_llm_config is None:
+            raise Exception("llm_config is not found in SERVER_CONFIG")
+
+        # Inject authentication_configuration into service configs BEFORE updating globals.
+        # Rule: service-level (lower) auth keys take precedence; missing keys fall back to top-level (upper).
+        if "authentication_configuration" in new_llm_config:
+            for svc_key in ["completion_service", "embedding_service", "multimodal_service", "chat_service"]:
+                if svc_key in new_llm_config:
+                    svc = new_llm_config[svc_key]
+                    if "authentication_configuration" not in svc:
+                        svc["authentication_configuration"] = new_llm_config["authentication_configuration"].copy()
+                    else:
+                        merged = new_llm_config["authentication_configuration"].copy()
+                        merged.update(svc["authentication_configuration"])
+                        svc["authentication_configuration"] = merged
+
+        new_completion_config = new_llm_config.get("completion_service")
+        new_embedding_config = new_llm_config.get("embedding_service")
+
+        if new_completion_config is None:
+            raise Exception("completion_service is not found in llm_config")
+        if new_embedding_config is None:
+            raise Exception("embedding_service is not found in llm_config")
+
+        # Validate required fields before touching globals
+        if "llm_service" not in new_completion_config:
+            raise Exception("llm_service is not found in completion_service")
+        if "llm_model" not in new_completion_config:
+            raise Exception("llm_model is not found in completion_service")
+
+        # Propagate top-level token_limit into service configs (same as startup)
+        if "token_limit" in new_llm_config:
+            if "token_limit" not in new_completion_config:
+                new_completion_config["token_limit"] = new_llm_config["token_limit"]
+            if "token_limit" not in new_embedding_config:
+                new_embedding_config["token_limit"] = new_llm_config["token_limit"]
+
+        # Update globals atomically: build complete new state, then swap in one step.
+        # Using dict slice assignment avoids the clear()+update() window where readers
+        # would see an empty dict.
+        old_llm_keys = set(llm_config.keys())
+        for k in old_llm_keys - set(new_llm_config.keys()):
+            del llm_config[k]
+        llm_config.update(new_llm_config)
+
+        # Re-initialize embedding service
+        if new_embedding_config["embedding_model_service"].lower() == "openai":
+            embedding_service = OpenAI_Embedding(new_embedding_config)
+        elif new_embedding_config["embedding_model_service"].lower() == "azure":
+            embedding_service = AzureOpenAI_Ada002(new_embedding_config)
+        elif new_embedding_config["embedding_model_service"].lower() == "vertexai":
+            embedding_service = VertexAI_PaLM_Embedding(new_embedding_config)
+        elif new_embedding_config["embedding_model_service"].lower() == "genai":
+            embedding_service = GenAI_Embedding(new_embedding_config)
+        elif new_embedding_config["embedding_model_service"].lower() == "bedrock":
+            embedding_service = AWS_Bedrock_Embedding(new_embedding_config)
+        elif new_embedding_config["embedding_model_service"].lower() == "ollama":
+            embedding_service = Ollama_Embedding(new_embedding_config)
+        else:
+            raise Exception("Embedding service not implemented")
+
+        return {
+            "status": "success",
+            "message": "LLM configuration reloaded successfully"
+        }
+
+    except Exception as e:
+        return {
+            "status": "error",
+            "message": f"Failed to reload LLM config: {str(e)}"
+        }
+
+
+def reload_db_config(new_db_config: dict = None):
+    """
+    Reload DB configuration from server_config.json and update in-memory config.
+    
+    Args:
+        new_db_config: If provided, saves this config to file first.
+                       If None, just reloads from existing file.
+    
+    Returns:
+        dict: Status of reload operation
+    """
+    global db_config
+
+    try:
+        with _config_file_lock:
+            if new_db_config is not None:
+                with open(SERVER_CONFIG, "r") as f:
+                    server_config = json.load(f)
+
+                server_config["db_config"] = new_db_config
+
+                temp_file = f"{SERVER_CONFIG}.tmp"
+                with open(temp_file, "w") as f:
+                    json.dump(server_config, f, indent=2)
+                os.replace(temp_file, SERVER_CONFIG)
+
+            with open(SERVER_CONFIG, "r") as f:
+                server_config = json.load(f)
+
+        new_db_config = server_config.get("db_config")
+        if new_db_config is None:
+            raise Exception("db_config is not found in SERVER_CONFIG")
+
+        old_db_keys = set(db_config.keys())
+        for k in old_db_keys - set(new_db_config.keys()):
+            del db_config[k]
+        db_config.update(new_db_config)
+
+        return {
+            "status": "success",
+            "message": "DB configuration reloaded successfully"
+        }
+    except Exception as e:
+        return {
+            "status": "error",
+            "message": f"Failed to reload DB config: {str(e)}"
+        }
+
+
+def reload_graphrag_config():
+    """
+    Reload GraphRAG configuration from server_config.json.
+    Updates the in-memory graphrag_config dict to reflect changes immediately.
+    
+    Returns:
+        dict: Status of reload operation
+    """
+    global graphrag_config
+
+    try:
+        with _config_file_lock:
+            with open(SERVER_CONFIG, "r") as f:
+                server_config = json.load(f)
+
+        new_graphrag_config = server_config.get("graphrag_config")
+        if new_graphrag_config is None:
+            new_graphrag_config = {"reuse_embedding": True}
+        
+        # Set defaults (same as startup logic)
+        if "chunker" not in new_graphrag_config:
+            new_graphrag_config["chunker"] = "semantic"
+        if "extractor" not in new_graphrag_config:
+            new_graphrag_config["extractor"] = "llm"
+        
+        # Update graphrag_config in-place to preserve references in other modules
+        old_graphrag_keys = set(graphrag_config.keys())
+        for k in old_graphrag_keys - set(new_graphrag_config.keys()):
+            del graphrag_config[k]
+        graphrag_config.update(new_graphrag_config)
+        
+        logger.info(f"GraphRAG config reloaded: extractor={graphrag_config.get('extractor')}, chunker={graphrag_config.get('chunker')}, reuse_embedding={graphrag_config.get('reuse_embedding')}")
+        
+        return {
+            "status": "success",
+            "message": "GraphRAG configuration reloaded successfully"
+        }
+        
+    except Exception as e:
+        return {
+            "status": "error",
+            "message": f"Failed to reload GraphRAG config: {str(e)}"
+        }
\ No newline at end of file
diff --git a/common/embeddings/embedding_services.py b/common/embeddings/embedding_services.py
index 1597cd2..6f170d0 100644
--- a/common/embeddings/embedding_services.py
+++ b/common/embeddings/embedding_services.py
@@ -184,9 +184,9 @@ class VertexAI_PaLM_Embedding(EmbeddingModel):
 
     def __init__(self, config):
         super().__init__(config, model_name=config.get("model_name", "VertexAI PaLM"))
-        from langchain.embeddings import VertexAIEmbeddings
+        from langchain_google_vertexai import VertexAIEmbeddings
 
-        self.embeddings = VertexAIEmbeddings(model_name=self.model_name)
+        self.embeddings = VertexAIEmbeddings(model=self.model_name)
 
 
 class GenAI_Embedding(EmbeddingModel):
@@ -243,3 +243,4 @@ def __init__(self, config):
             model=self.model_name,
             base_url=base_url
         )
+
diff --git a/common/extractors/GraphExtractor.py b/common/extractors/GraphExtractor.py
index 2a7ba50..9cf44cc 100644
--- a/common/extractors/GraphExtractor.py
+++ b/common/extractors/GraphExtractor.py
@@ -2,13 +2,13 @@
 from langchain_core.documents import Document
 from langchain_experimental.graph_transformers import LLMGraphTransformer
 
-from common.config import get_llm_service, llm_config
+from common.config import get_llm_service, get_completion_config
 from common.extractors.BaseExtractor import BaseExtractor
 
 
 class GraphExtractor(BaseExtractor):
     def __init__(self):
-        llm = get_llm_service(llm_config).llm
+        llm = get_llm_service(get_completion_config()).llm
         self.transformer = LLMGraphTransformer(
             llm=llm,
             node_properties=["description"],
diff --git a/common/extractors/LLMEntityRelationshipExtractor.py b/common/extractors/LLMEntityRelationshipExtractor.py
index b81a769..dec1753 100644
--- a/common/extractors/LLMEntityRelationshipExtractor.py
+++ b/common/extractors/LLMEntityRelationshipExtractor.py
@@ -13,6 +13,7 @@
 # limitations under the License.
 
 import json
+import re
 from typing import List
 import logging
 
@@ -37,6 +38,36 @@ def __init__(
         self.allowed_edge_types = allowed_relationship_types
         self.strict_mode = strict_mode
 
+    def _parse_json_output(self, content: str) -> dict:
+        """Parse JSON from LLM output with multiple fallback strategies.
+
+        Tries in order:
+          1. Direct json.loads
+          2. Extract from ```json code fences
+          3. Regex extraction of first JSON object
+        """
+        # Try direct parse
+        try:
+            return json.loads(content.strip("content="))
+        except (json.JSONDecodeError, ValueError):
+            pass
+
+        # Try ```json code fence
+        if "```json" in content:
+            try:
+                return json.loads(
+                    content.split("```")[1].strip("```").strip("json").strip()
+                )
+            except (json.JSONDecodeError, ValueError, IndexError):
+                pass
+
+        # Regex fallback: extract first JSON object
+        match = re.search(r'\{[\s\S]*\}', content)
+        if match:
+            return json.loads(match.group())
+
+        raise ValueError(f"Could not extract JSON from LLM output: {content[:200]}")
+
     async def _aextract_kg_from_doc(self, doc, chain, parser) -> list[GraphDocument]:
         try:
             logger.debug(str(doc))
@@ -47,12 +78,7 @@ async def _aextract_kg_from_doc(self, doc, chain, parser) -> list[GraphDocument]
         except Exception as e:
             return [GraphDocument(nodes=[], relationships=[], source=Document(page_content=doc))]
         try:
-            if "```json" not in out.content:
-                json_out = json.loads(out.content.strip("content="))
-            else:
-                json_out = json.loads(
-                    out.content.split("```")[1].strip("```").strip("json").strip()
-                )
+            json_out = self._parse_json_output(out.content)
 
             formatted_rels = []
             for rels in json_out["rels"]:
@@ -124,7 +150,7 @@ async def _aextract_kg_from_doc(self, doc, chain, parser) -> list[GraphDocument]
                         for rel in formatted_rels
                         if rel["type"] in self.allowed_edge_types
                     ]
-        
+
             nodes = []
             for node in formatted_nodes:
                 nodes.append(Node(id=node["id"],
@@ -141,7 +167,7 @@ async def _aextract_kg_from_doc(self, doc, chain, parser) -> list[GraphDocument]
 
         except:
             return [GraphDocument(nodes=[], relationships=[], source=Document(page_content=doc))]
-        
+
     def _extract_kg_from_doc(self, doc, chain, parser) -> list[GraphDocument]:
         try:
             out = chain.invoke(
@@ -150,12 +176,7 @@ def _extract_kg_from_doc(self, doc, chain, parser) -> list[GraphDocument]:
         except Exception as e:
             return [GraphDocument(nodes=[], relationships=[], source=Document(page_content=doc))]
         try:
-            if "```json" not in out.content:
-                json_out = json.loads(out.content.strip("content="))
-            else:
-                json_out = json.loads(
-                    out.content.split("```")[1].strip("```").strip("json").strip()
-                )
+            json_out = self._parse_json_output(out.content)
 
             formatted_rels = []
             for rels in json_out["rels"]:
@@ -278,7 +299,7 @@ async def adocument_er_extraction(self, document):
         if self.allowed_edge_types:
             prompt.append(("human", f"Allowed Edge Types: {self.allowed_edge_types}"))
         prompt = ChatPromptTemplate.from_messages(prompt)
-        chain = prompt | self.llm_service.model  # | parser
+        chain = prompt | self.llm_service.llm  # | parser
         er = await self._aextract_kg_from_doc(document, chain, parser)
         return er
 
@@ -316,7 +337,7 @@ def document_er_extraction(self, document):
         if self.allowed_edge_types:
             prompt.append(("human", f"Allowed Edge Types: {self.allowed_edge_types}"))
         prompt = ChatPromptTemplate.from_messages(prompt)
-        chain = prompt | self.llm_service.model  # | parser
+        chain = prompt | self.llm_service.llm  # | parser
         er = self._extract_kg_from_doc(document, chain, parser)
         return er
 
diff --git a/common/llm_services/aws_bedrock_service.py b/common/llm_services/aws_bedrock_service.py
index ba1b114..de6143a 100644
--- a/common/llm_services/aws_bedrock_service.py
+++ b/common/llm_services/aws_bedrock_service.py
@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os
 import boto3, botocore
 from langchain_aws import ChatBedrock
 import logging
@@ -57,53 +56,3 @@ def __init__(self, config):
         LogWriter.info(
             f"request_id={req_id_cv.get()} instantiated AWSBedrock model_name={model_name}"
         )
-
-    @property
-    def map_question_schema_prompt(self):
-        return self._read_prompt_file(self.prompt_path + "map_question_to_schema.txt")
-
-    @property
-    def generate_function_prompt(self):
-        return self._read_prompt_file(self.prompt_path + "generate_function.txt")
-
-    @property
-    def entity_relationship_extraction_prompt(self):
-        return self._read_prompt_file(
-            self.prompt_path + "entity_relationship_extraction.txt"
-        )
-
-    @property
-    def generate_cypher_prompt(self):
-        filepath = self.prompt_path + "generate_cypher.txt"
-        if os.path.exists(filepath):
-            return self._read_prompt_file(filepath)
-        else:
-            return super().generate_cypher_prompt
-
-    @property
-    def generate_gsql_prompt(self):
-        filepath = self.prompt_path + "generate_gsql.txt"
-        if os.path.exists(filepath):
-            return self._read_prompt_file(filepath)
-        else:
-            return super().generate_gsql_prompt
-
-    @property
-    def chatbot_response_prompt(self):
-        filepath = self.prompt_path + "chatbot_response.txt"
-        if os.path.exists(filepath):
-            return self._read_prompt_file(filepath)
-        else:
-            return super().chatbot_response_prompt
-
-    @property
-    def graphrag_scoring_prompt(self):
-        filepath = self.prompt_path + "graphrag_scoring.txt"
-        if os.path.exists(filepath):
-            return self._read_prompt_file(filepath)
-        else:
-            return super().graphrag_scoring_prompt
-
-    @property
-    def model(self):
-        return self.llm
diff --git a/common/llm_services/aws_sagemaker_endpoint.py b/common/llm_services/aws_sagemaker_endpoint.py
index fcc1cf3..5134497 100644
--- a/common/llm_services/aws_sagemaker_endpoint.py
+++ b/common/llm_services/aws_sagemaker_endpoint.py
@@ -54,15 +54,3 @@ def __init__(self, config):
         LogWriter.info(
             f"request_id={req_id_cv.get()} instantiated AWS_SageMaker_Endpoint model_name={model_name}"
         )
-
-    @property
-    def map_question_schema_prompt(self):
-        return self._read_prompt_file(self.prompt_path + "map_question_to_schema.txt")
-
-    @property
-    def generate_function_prompt(self):
-        return self._read_prompt_file(self.prompt_path + "generate_function.txt")
-
-    @property
-    def model(self):
-        return self.llm
diff --git a/common/llm_services/azure_openai_service.py b/common/llm_services/azure_openai_service.py
index e4dc6f5..bfb9279 100644
--- a/common/llm_services/azure_openai_service.py
+++ b/common/llm_services/azure_openai_service.py
@@ -21,7 +21,6 @@ def __init__(self, config):
             azure_deployment=config["azure_deployment"],
             openai_api_version=config["openai_api_version"],
             model_name=config["llm_model"],
-            max_tokens=config.get("token_limit"),
             temperature=config["model_kwargs"]["temperature"],
         )
 
@@ -29,21 +28,3 @@ def __init__(self, config):
         LogWriter.info(
             f"request_id={req_id_cv.get()} instantiated AzureOpenAI model_name={model_name}"
         )
-
-    @property
-    def map_question_schema_prompt(self):
-        return self._read_prompt_file(self.prompt_path + "map_question_to_schema.txt")
-
-    @property
-    def generate_function_prompt(self):
-        return self._read_prompt_file(self.prompt_path + "generate_function.txt")
-
-    @property
-    def entity_relationship_extraction_prompt(self):
-        return self._read_prompt_file(
-            self.prompt_path + "entity_relationship_extraction.txt"
-        )
-
-    @property
-    def model(self):
-        return self.llm
diff --git a/common/llm_services/base_llm.py b/common/llm_services/base_llm.py
index 1dafd3d..ba1c770 100644
--- a/common/llm_services/base_llm.py
+++ b/common/llm_services/base_llm.py
@@ -12,6 +12,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import os
+import re
+import logging
+from langchain_core.output_parsers import BaseOutputParser, PydanticOutputParser
+from langchain_core.exceptions import OutputParserException
+from langchain_core.prompts import BasePromptTemplate
+from langchain_community.callbacks.manager import get_openai_callback
+
+logger = logging.getLogger(__name__)
+
+
 class LLM_Model:
     """Base LLM_Model Class
 
@@ -20,26 +31,142 @@ class LLM_Model:
 
     def __init__(self, config):
         self.llm = None
+        self.config = config
+        from common.config import validate_graphname
+        self._graphname = validate_graphname(config.get("graphname"))
+        self.prompt_path = config.get("prompt_path", "")
 
     def _read_prompt_file(self, path):
-        with open(path) as f:
-            prompt = f.read()
-        return prompt
+        """Read a prompt file with per-graph override support.
+
+        Resolution order:
+          1. configs/graph_configs/<graphname>/prompts/<filename> (if graphname is set)
+          2. Original path (from prompt_path config)
+
+        Returns the file content, or None if the file doesn't exist anywhere.
+        """
+        filename = os.path.basename(path)
+        if self._graphname:
+            graph_override = os.path.join(
+                "configs", "graph_configs", self._graphname, "prompts", filename
+            )
+            if os.path.exists(graph_override):
+                with open(graph_override) as f:
+                    return f.read()
+        if os.path.exists(path):
+            with open(path) as f:
+                return f.read()
+        return None
+
+    def invoke_with_parser(
+        self,
+        prompt: BasePromptTemplate,
+        parser: BaseOutputParser,
+        input_variables: dict,
+        caller_name: str = "unknown",
+    ):
+        """Invoke the LLM with a prompt and parse the output using the given parser.
+
+        Builds a chain (prompt | llm), invokes it, and parses the output.
+        Supports PydanticOutputParser (with JSON extraction fallback)
+        and StrOutputParser (returns raw text).
+
+        Args:
+            prompt: The prompt template.
+            parser: The output parser (PydanticOutputParser, StrOutputParser, etc.).
+            input_variables: Dict of variables to pass to the prompt.
+            caller_name: Name of the calling function (for logging).
+
+        Returns:
+            Parsed Pydantic model instance.
+
+        Raises:
+            OutputParserException: If all parsing attempts fail.
+        """
+
+        chain = prompt | self.llm
+
+        usage_data = {}
+        with get_openai_callback() as cb:
+            raw_output = chain.invoke(input_variables)
+
+            usage_data["input_tokens"] = cb.prompt_tokens
+            usage_data["output_tokens"] = cb.completion_tokens
+            usage_data["total_tokens"] = cb.total_tokens
+            usage_data["cost"] = cb.total_cost
+            logger.info(f"{caller_name} usage: {usage_data}")
+
+        raw_text = raw_output.content if hasattr(raw_output, "content") else str(raw_output)
+
+        try:
+            return parser.parse(raw_text)
+        except OutputParserException:
+            logger.warning(f"{caller_name}: parser failed, attempting JSON extraction")
+            json_match = re.search(r'\{[\s\S]*\}', raw_text)
+            if json_match:
+                return parser.parse(json_match.group())
+            raise
+
+    async def ainvoke_with_parser(
+        self,
+        prompt: BasePromptTemplate,
+        parser: BaseOutputParser,
+        input_variables: dict,
+        caller_name: str = "unknown",
+    ):
+        """Async version of invoke_with_parser.
+
+        Uses chain.ainvoke() to avoid blocking the event loop,
+        suitable for async callers (e.g., ECC workers).
+        """
+
+        chain = prompt | self.llm
+
+        usage_data = {}
+        with get_openai_callback() as cb:
+            raw_output = await chain.ainvoke(input_variables)
+
+            usage_data["input_tokens"] = cb.prompt_tokens
+            usage_data["output_tokens"] = cb.completion_tokens
+            usage_data["total_tokens"] = cb.total_tokens
+            usage_data["cost"] = cb.total_cost
+            logger.info(f"{caller_name} usage: {usage_data}")
+
+        raw_text = raw_output.content if hasattr(raw_output, "content") else str(raw_output)
+
+        try:
+            return parser.parse(raw_text)
+        except OutputParserException:
+            logger.warning(f"{caller_name}: parser failed, attempting JSON extraction")
+            json_match = re.search(r'\{[\s\S]*\}', raw_text)
+            if json_match:
+                return parser.parse(json_match.group())
+            raise
 
     @property
     def map_question_schema_prompt(self):
         """Property to get the prompt for the MapQuestionToSchema tool."""
-        raise ("map_question_schema_prompt not supported in base class")
+        return self._read_prompt_file(self.prompt_path + "map_question_to_schema.txt")
 
     @property
     def generate_function_prompt(self):
         """Property to get the prompt for the GenerateFunction tool."""
-        raise ("generate_function_prompt not supported in base class")
+        return self._read_prompt_file(self.prompt_path + "generate_function.txt")
+
+    @property
+    def entity_relationship_extraction_prompt(self):
+        """Property to get the prompt for the EntityRelationshipExtraction tool."""
+        return self._read_prompt_file(
+            self.prompt_path + "entity_relationship_extraction.txt"
+        )
 
     @property
     def generate_cypher_prompt(self):
         """Property to get the prompt for the GenerateCypher tool."""
-        prompt = """You're an expert in OpenCypher programming. Given the following schema and history, what is the OpenCypher query that retrieves the {question}
+        result = self._read_prompt_file(self.prompt_path + "generate_cypher.txt")
+        if result is not None:
+            return result
+        return """You're an expert in OpenCypher programming. Given the following schema and history, what is the OpenCypher query that retrieves the {question}
                     Only include attributes that are found in the schema. Never include any attributes that are not found in the schema.
                     Use attributes instead of primary id if attribute name is closer to the keyword type in the question.
                     Use as less vertex type, edge type and attributes as possible. If an attribute is not found in the schema, please exclude it from the query.
@@ -65,12 +192,14 @@ def generate_cypher_prompt(self):
                     Make sure to have correct attribute names in the OpenCypher query and not to name result aliases that are vertex or edge types.
 
                     ONLY write the OpenCypher query in the response. Do not include any other information in the response."""
-        return prompt
 
     @property
     def generate_gsql_prompt(self):
         """Property to get the prompt for the GenerateGSQL tool."""
-        prompt = """You're an expert in GSQL (Graph SQL) programming for TigerGraph. Given the following schema: {schema}, what is the GSQL query that retrieves the answer for question: {question}
+        result = self._read_prompt_file(self.prompt_path + "generate_gsql.txt")
+        if result is not None:
+            return result
+        return """You're an expert in GSQL (Graph SQL) programming for TigerGraph. Given the following schema: {schema}, what is the GSQL query that retrieves the answer for question: {question}
                     Only include attributes that are found in the schema. Never include any attributes that are not found in the schema.
                     Use attributes instead of primary id if attribute name is more similar to the keyword type in the question.
                     Use as few vertex types, edge types and attributes as possible. If an attribute is not found in the schema, please exclude it from the query.
@@ -101,12 +230,14 @@ def generate_gsql_prompt(self):
                     Make sure to have correct attribute names in the GSQL query and not to name result aliases that are vertex or edge types, operator or function names, and other reserved keywords, always construct alias with multiple words connected with underscore.
 
                     ONLY write the GSQL query in the response. Do not include any other information in the response."""
-        return prompt
 
     @property
     def route_response_prompt(self):
         """Property to get the prompt for the RouteResponse tool."""
-        prompt = """\
+        result = self._read_prompt_file(self.prompt_path + "route_response.txt")
+        if result is not None:
+            return result
+        return """\
 You are an expert at routing a user question to a vectorstore, function calls, or conversation history.
 Use the conversation history for questions that are similar to previous ones or that reference earlier answers or responses.
 Use the vectorstore for questions that would be best suited by text documents.
@@ -126,50 +257,74 @@ def route_response_prompt(self):
 Conversation history: {conversation}
 Format: {format_instructions}\
 """
-        return prompt
 
     @property
     def hyde_prompt(self):
         """Property to get the prompt for the HyDE tool."""
+        result = self._read_prompt_file(self.prompt_path + "hyde.txt")
+        if result is not None:
+            return result
         return """You are a helpful agent that is writing an example of a document that might answer this question: {question}
                   Answer:"""
 
-    @property
-    def entity_relationship_extraction_prompt(self):
-        """Property to get the prompt for the EntityRelationshipExtraction tool."""
-        raise ("entity_relationship_extraction_prompt not supported in base class")
-
     @property
     def chatbot_response_prompt(self):
         """Property to get the prompt for the SupportAI response."""
-        prompt ="""Given the answer context in JSON format, rephrase it to answer the question. \n
+        result = self._read_prompt_file(self.prompt_path + "chatbot_response.txt")
+        if result is not None:
+            return result
+        return """Given the answer context in JSON format, rephrase it to answer the question. \n
                    Use only the provided information in context without adding any reasoning or additional logic. \n
                    Make sure all information in the answer are covered in the generated answer.\n
 
                    Question: {question} \n
                    Answer: {context} \n
                    Format: {format_instructions}"""
-        return prompt
 
     @property
     def keyword_extraction_prompt(self):
-        """Property to get the prompt for the Question Expension response."""
+        """Property to get the prompt for the Question Expansion response."""
+        result = self._read_prompt_file(self.prompt_path + "keyword_extraction.txt")
+        if result is not None:
+            return result
         return """You are a helpful assistant responsible for extracting key terms (glossary) from all the questions below to represent their original meaning as much as possible. Each term should only contain a couple of words. Include a quality score for the each extracted glossary, based on how important and frequent it's in the given questions. The quality score should range from 0 (poor) to 100 (excellent), with higher scores indicating terms that are both significant and frequent in the context of the questions.\nThe output should only contain the extracted terms and their quality scores using the required format.\n\nQuestion: {question}\n\n{format_instructions}\n"""
 
     @property
     def question_expansion_prompt(self):
-        """Property to get the prompt for the Question Expension response."""
+        """Property to get the prompt for the Question Expansion response."""
+        result = self._read_prompt_file(self.prompt_path + "question_expansion.txt")
+        if result is not None:
+            return result
         return """You are a helpful assistant responsible for generating 10 new questions similar to the original question below to represent its meaning in a more clear way.\nInclude a quality score for the answer, based on how well it represents the meaning of the original question. The quality score should be between 0 (poor) and 100 (excellent).\n\nQuestion: {question}\n\n{format_instructions}\n"""
 
     @property
     def graphrag_scoring_prompt(self):
         """Property to get the prompt for the GraphRAG Scoring response."""
+        result = self._read_prompt_file(self.prompt_path + "graphrag_scoring.txt")
+        if result is not None:
+            return result
         return """You are a helpful assistant responsible for generating an answer to the question below using the data provided.\nInclude a quality score for the answer, based on how well it answers the question. The quality score should be between 0 (poor) and 100 (excellent).\n\nQuestion: {question}\nContext: {context}\n\n{format_instructions}\n"""
 
+    @property
+    def community_summarize_prompt(self):
+        """Property to get the prompt for community summarization."""
+        result = self._read_prompt_file(self.prompt_path + "community_summarization.txt")
+        if result is not None:
+            return result
+        raise FileNotFoundError(
+            f"Community summarization prompt file not found in {self.prompt_path}. "
+            "Please ensure community_summarization.txt exists in the configured prompt path."
+        )
+
     @property
     def contextualize_question_prompt(self):
         """Property to get the prompt for contextualizing a follow-up question
         into a standalone search query using conversation history."""
+        result = self._read_prompt_file(
+            self.prompt_path + "contextualize_question.txt"
+        )
+        if result is not None:
+            return result
         return (
             "Given the following conversation history and a follow-up "
             "question, rewrite the follow-up question into a standalone, "
@@ -180,7 +335,3 @@ def contextualize_question_prompt(self):
             "Standalone question:"
         )
 
-    @property
-    def model(self):
-        """Property to get the external LLM model."""
-        raise ("model not supported in base class")
diff --git a/common/llm_services/google_genai_service.py b/common/llm_services/google_genai_service.py
index c544978..54d3a20 100644
--- a/common/llm_services/google_genai_service.py
+++ b/common/llm_services/google_genai_service.py
@@ -36,7 +36,6 @@ def __init__(self, config):
         self.llm = ChatGoogleGenerativeAI(
             temperature=config["model_kwargs"]["temperature"],
             model=model_name,
-            max_tokens=config.get("token_limit"),
             timeout=None,
             max_retries=2,
         )
@@ -44,85 +43,3 @@ def __init__(self, config):
         LogWriter.info(
             f"request_id={req_id_cv.get()} instantiated OpenAI model_name={model_name}"
         )
-
-    @property
-    def map_question_schema_prompt(self):
-        return self._read_prompt_file(self.prompt_path + "map_question_to_schema.txt")
-
-    @property
-    def generate_function_prompt(self):
-        return self._read_prompt_file(self.prompt_path + "generate_function.txt")
-
-    @property
-    def generate_cypher_prompt(self):
-        filepath = self.prompt_path + "generate_cypher.txt"
-        if os.path.exists(filepath):
-            return self._read_prompt_file(filepath)
-        else:
-            return super().generate_cypher_prompt
-
-    @property
-    def generate_gsql_prompt(self):
-        filepath = self.prompt_path + "generate_gsql.txt"
-        if os.path.exists(filepath):
-            return self._read_prompt_file(filepath)
-        else:
-            return super().generate_gsql_prompt
-
-    @property
-    def entity_relationship_extraction_prompt(self):
-        return self._read_prompt_file(
-            self.prompt_path + "entity_relationship_extraction.txt"
-        )
-
-    @property
-    def route_response_prompt(self):
-        filepath = self.prompt_path + "route_response.txt"
-        if os.path.exists(filepath):
-            return self._read_prompt_file(filepath)
-        else:
-            return super().route_response_prompt
-
-    @property
-    def graphrag_scoring_prompt(self):
-        filepath = self.prompt_path + "graphrag_scoring.txt"
-        if os.path.exists(filepath):
-            return self._read_prompt_file(filepath)
-        else:
-            return super().graphrag_scoring_prompt
-
-    @property
-    def keyword_extraction_prompt(self):
-        filepath = self.prompt_path + "keyword_extraction.txt"
-        if os.path.exists(filepath):
-            return self._read_prompt_file(filepath)
-        else:
-            return super().keyword_extraction_prompt
-
-    @property
-    def question_expansion_prompt(self):
-        filepath = self.prompt_path + "question_expansion.txt"
-        if os.path.exists(filepath):
-            return self._read_prompt_file(filepath)
-        else:
-            return super().question_expansion_prompt
-
-    @property
-    def chatbot_response_prompt(self):
-        filepath = self.prompt_path + "chatbot_response.txt"
-        if os.path.exists(filepath):
-            return self._read_prompt_file(filepath)
-        else:
-            return super().chatbot_response_prompt
-
-    @property
-    def hyde_prompt(self):
-        filepath = self.prompt_path + "hyde.txt"
-        if os.path.exists(filepath):
-            return self._read_prompt_file(filepath)
-        else:
-            return super().hyde_prompt
-
-    @property
-    def model(self):
-        return self.llm
diff --git a/common/llm_services/google_vertexai_service.py b/common/llm_services/google_vertexai_service.py
index 22679f5..2bc9847 100644
--- a/common/llm_services/google_vertexai_service.py
+++ b/common/llm_services/google_vertexai_service.py
@@ -9,11 +9,11 @@
 class GoogleVertexAI(LLM_Model):
     def __init__(self, config):
         super().__init__(config)
-        from langchain_community.llms import VertexAI
+        from langchain_google_vertexai import VertexAI
 
         model_name = config["llm_model"]
         self.llm = VertexAI(
-            model_name=model_name, max_output_tokens=1000, **config["model_kwargs"]
+            model=model_name, max_output_tokens=1000, **config["model_kwargs"]
         )
 
         self.prompt_path = config["prompt_path"]
@@ -21,20 +21,3 @@ def __init__(self, config):
             f"request_id={req_id_cv.get()} instantiated GoogleVertexAI model_name={model_name}"
         )
 
-    @property
-    def map_question_schema_prompt(self):
-        return self._read_prompt_file(self.prompt_path + "map_question_to_schema.txt")
-
-    @property
-    def generate_function_prompt(self):
-        return self._read_prompt_file(self.prompt_path + "generate_function.txt")
-
-    @property
-    def entity_relationship_extraction_prompt(self):
-        return self._read_prompt_file(
-            self.prompt_path + "entity_relationship_extraction.txt"
-        )
-
-    @property
-    def model(self):
-        return self.llm
diff --git a/common/llm_services/groq_llm_service.py b/common/llm_services/groq_llm_service.py
index afa6f89..b1e58ee 100644
--- a/common/llm_services/groq_llm_service.py
+++ b/common/llm_services/groq_llm_service.py
@@ -22,21 +22,3 @@ def __init__(self, config):
         LogWriter.info(
             f"request_id={req_id_cv.get()} instantiated OpenAI model_name={model_name}"
         )
-
-    @property
-    def map_question_schema_prompt(self):
-        return self._read_prompt_file(self.prompt_path + "map_question_to_schema.txt")
-
-    @property
-    def generate_function_prompt(self):
-        return self._read_prompt_file(self.prompt_path + "generate_function.txt")
-
-    @property
-    def entity_relationship_extraction_prompt(self):
-        return self._read_prompt_file(
-            self.prompt_path + "entity_relationship_extraction.txt"
-        )
-
-    @property
-    def model(self):
-        return self.llm
diff --git a/common/llm_services/huggingface_endpoint.py b/common/llm_services/huggingface_endpoint.py
index 2151966..5b83916 100644
--- a/common/llm_services/huggingface_endpoint.py
+++ b/common/llm_services/huggingface_endpoint.py
@@ -31,21 +31,3 @@ def __init__(self, config):
         LogWriter.info(
             f"request_id={req_id_cv.get()} instantiated HuggingFace  model_name={model_name}"
         )
-
-    @property
-    def map_question_schema_prompt(self):
-        return self._read_prompt_file(self.prompt_path + "map_question_to_schema.txt")
-
-    @property
-    def generate_function_prompt(self):
-        return self._read_prompt_file(self.prompt_path + "generate_function.txt")
-
-    @property
-    def entity_relationship_extraction_prompt(self):
-        return self._read_prompt_file(
-            self.prompt_path + "entity_relationship_extraction.txt"
-        )
-
-    @property
-    def model(self):
-        return self.llm
diff --git a/common/llm_services/ibm_watsonx_service.py b/common/llm_services/ibm_watsonx_service.py
index b2504da..e4c9d99 100644
--- a/common/llm_services/ibm_watsonx_service.py
+++ b/common/llm_services/ibm_watsonx_service.py
@@ -30,21 +30,3 @@ def __init__(self, config):
         LogWriter.info(
             f"request_id={req_id_cv.get()} instantiated WatsonX model_name={model_name}"
         )
-
-    @property
-    def map_question_schema_prompt(self):
-        return self._read_prompt_file(self.prompt_path + "map_question_to_schema.txt")
-
-    @property
-    def generate_function_prompt(self):
-        return self._read_prompt_file(self.prompt_path + "generate_function.txt")
-
-    @property
-    def entity_relationship_extraction_prompt(self):
-        return self._read_prompt_file(
-            self.prompt_path + "entity_relationship_extraction.txt"
-        )
-
-    @property
-    def model(self):
-        return self.llm
diff --git a/common/llm_services/ollama.py b/common/llm_services/ollama.py
index bdb0b44..40d5c97 100644
--- a/common/llm_services/ollama.py
+++ b/common/llm_services/ollama.py
@@ -17,21 +17,3 @@ def __init__(self, config):
         LogWriter.info(
             f"request_id={req_id_cv.get()} instantiated Ollama model_name={model_name}"
         )
-
-    @property
-    def map_question_schema_prompt(self):
-        return self._read_prompt_file(self.prompt_path + "map_question_to_schema.txt")
-
-    @property
-    def generate_function_prompt(self):
-        return self._read_prompt_file(self.prompt_path + "generate_function.txt")
-
-    @property
-    def entity_relationship_extraction_prompt(self):
-        return self._read_prompt_file(
-            self.prompt_path + "entity_relationship_extraction.txt"
-        )
-
-    @property
-    def model(self):
-        return self.llm
diff --git a/common/llm_services/openai_service.py b/common/llm_services/openai_service.py
index f23e81b..e5f1c6d 100644
--- a/common/llm_services/openai_service.py
+++ b/common/llm_services/openai_service.py
@@ -43,85 +43,3 @@ def __init__(self, config):
         LogWriter.info(
             f"request_id={req_id_cv.get()} instantiated OpenAI model_name={model_name}"
         )
-
-    @property
-    def map_question_schema_prompt(self):
-        return self._read_prompt_file(self.prompt_path + "map_question_to_schema.txt")
-
-    @property
-    def generate_function_prompt(self):
-        return self._read_prompt_file(self.prompt_path + "generate_function.txt")
-
-    @property
-    def generate_cypher_prompt(self):
-        filepath = self.prompt_path + "generate_cypher.txt"
-        if os.path.exists(filepath):
-            return self._read_prompt_file(filepath)
-        else:
-            return super().generate_cypher_prompt
-
-    @property
-    def generate_gsql_prompt(self):
-        filepath = self.prompt_path + "generate_gsql.txt"
-        if os.path.exists(filepath):
-            return self._read_prompt_file(filepath)
-        else:
-            return super().generate_gsql_prompt
-
-    @property
-    def entity_relationship_extraction_prompt(self):
-        return self._read_prompt_file(
-            self.prompt_path + "entity_relationship_extraction.txt"
-        )
-
-    @property
-    def route_response_prompt(self):
-        filepath = self.prompt_path + "route_response.txt"
-        if os.path.exists(filepath):
-            return self._read_prompt_file(filepath)
-        else:
-            return super().route_response_prompt
-
-    @property
-    def graphrag_scoring_prompt(self):
-        filepath = self.prompt_path + "graphrag_scoring.txt"
-        if os.path.exists(filepath):
-            return self._read_prompt_file(filepath)
-        else:
-            return super().graphrag_scoring_prompt
-
-    @property
-    def keyword_extraction_prompt(self):
-        filepath = self.prompt_path + "keyword_extraction.txt"
-        if os.path.exists(filepath):
-            return self._read_prompt_file(filepath)
-        else:
-            return super().keyword_extraction_prompt
-
-    @property
-    def question_expansion_prompt(self):
-        filepath = self.prompt_path + "question_expansion.txt"
-        if os.path.exists(filepath):
-            return self._read_prompt_file(filepath)
-        else:
-            return super().question_expansion_prompt
-
-    @property
-    def chatbot_response_prompt(self):
-        filepath = self.prompt_path + "chatbot_response.txt"
-        if os.path.exists(filepath):
-            return self._read_prompt_file(filepath)
-        else:
-            return super().chatbot_response_prompt
-
-    @property
-    def hyde_prompt(self):
-        filepath = self.prompt_path + "hyde.txt"
-        if os.path.exists(filepath):
-            return self._read_prompt_file(filepath)
-        else:
-            return super().hyde_prompt
-
-    @property
-    def model(self):
-        return self.llm
diff --git a/common/metrics/tg_proxy.py b/common/metrics/tg_proxy.py
index 804d66f..a9a325f 100644
--- a/common/metrics/tg_proxy.py
+++ b/common/metrics/tg_proxy.py
@@ -5,6 +5,7 @@
 from common.logs.logwriter import LogWriter
 import logging
 from common.logs.log import req_id_cv
+from common.config import db_config
 
 
 logger = logging.getLogger(__name__)
@@ -47,7 +48,9 @@ def _runInstalledQuery(self, query_name, params, sizeLimit=None, usePost=False):
         metrics.tg_inprogress_requests.labels(query_name=query_name).inc()
         try:
             restppid = self._tg_connection.runInstalledQuery(
-                query_name, params, runAsync=True, usePost=usePost, sizeLimit=sizeLimit
+                query_name, params, runAsync=True, usePost=usePost, sizeLimit=sizeLimit,
+                threadLimit=db_config.get("default_thread_limit", 8),
+                memoryLimit=db_config.get("default_mem_threshold", 5000),
             )
             LogWriter.info(
                 f"request_id={req_id_cv.get()} query {query_name} started with RESTPP ID {restppid}"
diff --git a/common/prompts/aws_bedrock_claude3haiku/community_summarization.txt b/common/prompts/aws_bedrock_claude3haiku/community_summarization.txt
new file mode 100644
index 0000000..50e4619
--- /dev/null
+++ b/common/prompts/aws_bedrock_claude3haiku/community_summarization.txt
@@ -0,0 +1,11 @@
+You are a helpful assistant responsible for generating a comprehensive summary of the data provided below.
+Given one or two entities, and a list of descriptions, all related to the same entity or group of entities.
+Please concatenate all of these into a single, comprehensive description. Make sure to include information collected from all the descriptions.
+If the provided descriptions are contradictory, please resolve the contradictions and provide a single, coherent summary, but do not add any information that is not in the description.
+Make sure it is written in third person, and include the entity names so we the have full context.
+
+#######
+-Data-
+Commuinty Title: {entity_name}
+Description List: {description_list}
+
diff --git a/common/prompts/custom/aml/community_summarization.txt b/common/prompts/custom/aml/community_summarization.txt
new file mode 100644
index 0000000..50e4619
--- /dev/null
+++ b/common/prompts/custom/aml/community_summarization.txt
@@ -0,0 +1,11 @@
+You are a helpful assistant responsible for generating a comprehensive summary of the data provided below.
+Given one or two entities, and a list of descriptions, all related to the same entity or group of entities.
+Please concatenate all of these into a single, comprehensive description. Make sure to include information collected from all the descriptions.
+If the provided descriptions are contradictory, please resolve the contradictions and provide a single, coherent summary, but do not add any information that is not in the description.
+Make sure it is written in third person, and include the entity names so we the have full context.
+
+#######
+-Data-
+Commuinty Title: {entity_name}
+Description List: {description_list}
+
diff --git a/common/prompts/gcp_vertexai_palm/community_summarization.txt b/common/prompts/gcp_vertexai_palm/community_summarization.txt
new file mode 100644
index 0000000..50e4619
--- /dev/null
+++ b/common/prompts/gcp_vertexai_palm/community_summarization.txt
@@ -0,0 +1,11 @@
+You are a helpful assistant responsible for generating a comprehensive summary of the data provided below.
+Given one or two entities, and a list of descriptions, all related to the same entity or group of entities.
+Please concatenate all of these into a single, comprehensive description. Make sure to include information collected from all the descriptions.
+If the provided descriptions are contradictory, please resolve the contradictions and provide a single, coherent summary, but do not add any information that is not in the description.
+Make sure it is written in third person, and include the entity names so we the have full context.
+
+#######
+-Data-
+Commuinty Title: {entity_name}
+Description List: {description_list}
+
diff --git a/common/prompts/google_gemini/community_summarization.txt b/common/prompts/google_gemini/community_summarization.txt
new file mode 100644
index 0000000..50e4619
--- /dev/null
+++ b/common/prompts/google_gemini/community_summarization.txt
@@ -0,0 +1,11 @@
+You are a helpful assistant responsible for generating a comprehensive summary of the data provided below.
+Given one or two entities, and a list of descriptions, all related to the same entity or group of entities.
+Please concatenate all of these into a single, comprehensive description. Make sure to include information collected from all the descriptions.
+If the provided descriptions are contradictory, please resolve the contradictions and provide a single, coherent summary, but do not add any information that is not in the description.
+Make sure it is written in third person, and include the entity names so we the have full context.
+
+#######
+-Data-
+Commuinty Title: {entity_name}
+Description List: {description_list}
+
diff --git a/common/prompts/openai_gpt4/community_summarization.txt b/common/prompts/openai_gpt4/community_summarization.txt
new file mode 100644
index 0000000..50e4619
--- /dev/null
+++ b/common/prompts/openai_gpt4/community_summarization.txt
@@ -0,0 +1,11 @@
+You are a helpful assistant responsible for generating a comprehensive summary of the data provided below.
+Given one or two entities, and a list of descriptions, all related to the same entity or group of entities.
+Please concatenate all of these into a single, comprehensive description. Make sure to include information collected from all the descriptions.
+If the provided descriptions are contradictory, please resolve the contradictions and provide a single, coherent summary, but do not add any information that is not in the description.
+Make sure it is written in third person, and include the entity names so we the have full context.
+
+#######
+-Data-
+Commuinty Title: {entity_name}
+Description List: {description_list}
+
diff --git a/common/requirements.txt b/common/requirements.txt
index d5a2d5b..12c9fcf 100644
--- a/common/requirements.txt
+++ b/common/requirements.txt
@@ -80,6 +80,7 @@ kiwisolver==1.4.8
 langchain>=0.3.26
 langchain-core>=0.3.26
 langchain_google_genai==2.1.8
+langchain-google-vertexai==2.1.2
 langchain-community==0.3.26
 langchain-experimental==0.3.5rc1
 langchain-groq==0.3.4
diff --git a/common/utils/image_data_extractor.py b/common/utils/image_data_extractor.py
index 19da86e..48f9b65 100644
--- a/common/utils/image_data_extractor.py
+++ b/common/utils/image_data_extractor.py
@@ -2,7 +2,7 @@
 import io
 import logging
 from langchain_core.messages import HumanMessage, SystemMessage
-from common.config import get_multimodal_service
+from common.config import get_llm_service, get_multimodal_config
 
 logger = logging.getLogger(__name__)
 
@@ -10,8 +10,11 @@
 
 def _get_client():
     global _multimodal_client
-    if _multimodal_client is None:
-        _multimodal_client = get_multimodal_service()
+    if _multimodal_client is None and get_multimodal_config():
+        try:
+            _multimodal_client = get_llm_service(get_multimodal_config())
+        except Exception:
+            logger.warning("Failed to create multimodal LLM client")
     return _multimodal_client
 
 def describe_image_with_llm(file_path):
diff --git a/common/utils/token_calculator.py b/common/utils/token_calculator.py
index 762e824..dfe4a76 100644
--- a/common/utils/token_calculator.py
+++ b/common/utils/token_calculator.py
@@ -61,12 +61,31 @@ def __init__(self, token_limit: int = 0, model_name: str = None):
         self.max_context_tokens = token_limit if token_limit else 0
         self.model_name = model_name if model_name else "gpt-4"
         try:
-            self.token_encoding = tiktoken.encoding_for_model(self.model_name)
+            self.token_encoding = tiktoken.encoding_for_model(self._normalize_model_name(self.model_name))
         except Exception as e:
             self.token_encoding = tiktoken.get_encoding("cl100k_base")
-            logger.warning(f"Error getting encoding for model {self.model_name}, using cl100k_base: {e}")
+            logger.info(f"No tiktoken mapping for model {self.model_name}, using cl100k_base")
         logger.info(f"Initialized TokenCalculator with max_context_tokens: {self.max_context_tokens} and encoding: {self.token_encoding}")
 
+    @staticmethod
+    def _normalize_model_name(model_name: str) -> str:
+        """Normalize provider-specific model names for tiktoken lookup.
+
+        Examples:
+            anthropic.claude-3-5-haiku-20241022-v1:0 → claude-3-5-haiku
+            us.anthropic.claude-3-5-haiku-20241022-v1:0 → claude-3-5-haiku
+            gpt-4o-mini → gpt-4o-mini (unchanged)
+        """
+        name = model_name
+        # Strip Bedrock provider prefix (e.g., "anthropic." or "us.anthropic.")
+        if "." in name:
+            name = name.rsplit(".", 1)[-1]
+        # Strip version suffix (e.g., "-20241022-v1:0")
+        # Pattern: date stamp followed by version
+        import re
+        name = re.sub(r'-\d{8}-v\d+.*$', '', name)
+        return name
+
     def set_max_context_tokens(self, max_tokens: int):
         """Set the maximum number of tokens allowed for retrieved context."""
         self.max_context_tokens = max_tokens
diff --git a/docker-compose.yml b/docker-compose.yml
index b228151..97a0952 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -74,7 +74,7 @@ services:
       - graphrag
 
 #   tigergraph:
-#     image: tigergraph/community:4.2.1
+#     image: tigergraph/community:4.2.2
 #     container_name: tigergraph
 #     platform: linux/amd64
 #     ports:
diff --git a/docs/tutorials/configs/nginx.conf b/docs/tutorials/configs/nginx.conf
index dc09929..975d8a0 100644
--- a/docs/tutorials/configs/nginx.conf
+++ b/docs/tutorials/configs/nginx.conf
@@ -14,6 +14,16 @@ server {
     proxy_pass http://graphrag-ui:3000/;
   }
 
+  location /setup {
+    rewrite ^/setup$ / break;
+    proxy_pass http://graphrag-ui:3000;
+  }
+
+  location /setup/ {
+    rewrite ^/setup/.*$ / break;
+    proxy_pass http://graphrag-ui:3000;
+  }
+
 
   location /chat-dialog {
     proxy_pass http://graphrag-ui:3000/;
diff --git a/docs/tutorials/docker-compose.yml b/docs/tutorials/docker-compose.yml
index 8be754b..2d5734c 100644
--- a/docs/tutorials/docker-compose.yml
+++ b/docs/tutorials/docker-compose.yml
@@ -74,7 +74,7 @@ services:
       - graphrag
 
   tigergraph:
-    image: tigergraph/community:4.2.1
+    image: tigergraph/community:4.2.2
     container_name: tigergraph
     platform: linux/amd64
     ports:
diff --git a/docs/tutorials/setup_graphrag.sh b/docs/tutorials/setup_graphrag.sh
index cb818b8..a3540a6 100755
--- a/docs/tutorials/setup_graphrag.sh
+++ b/docs/tutorials/setup_graphrag.sh
@@ -40,7 +40,7 @@ cd $root_dir || { echo "Cannot switch to $root_dir!"; exit 5; }
 
 echo "Downloading GraphRAG service config..."
 mkdir -p configs || true
-curl -sk https://raw.githubusercontent.com/tigergraph/graphrag/refs/heads/main/docs/tutorials/docker-compose.yml | sed "s/community:4.2.1/community:${tg_version}/g" > docker-compose.yml
+curl -sk https://raw.githubusercontent.com/tigergraph/graphrag/refs/heads/main/docs/tutorials/docker-compose.yml | sed "s/community:4.2.2/community:${tg_version}/g" > docker-compose.yml
 curl -sk https://raw.githubusercontent.com/tigergraph/graphrag/refs/heads/main/docs/tutorials/configs/nginx.conf -o configs/nginx.conf
 curl -sk "https://raw.githubusercontent.com/tigergraph/graphrag/refs/heads/main/docs/tutorials/configs/server_config.json.${llm_provider}" | sed '/"gsPort": "14240"/a\
     "username": "'${tg_username}'",\
diff --git a/ecc/app/ecc_util.py b/ecc/app/ecc_util.py
index 35bbcaa..e17ce9f 100644
--- a/ecc/app/ecc_util.py
+++ b/ecc/app/ecc_util.py
@@ -1,21 +1,11 @@
 from common.chunkers import character_chunker, regex_chunker, semantic_chunker, markdown_chunker, recursive_chunker, html_chunker, single_chunker
-from common.config import graphrag_config, embedding_service, llm_config
-from common.llm_services import (
-    AWS_SageMaker_Endpoint,
-    AWSBedrock,
-    AzureOpenAI,
-    GoogleVertexAI,
-    GoogleGenAI,
-    Groq,
-    HuggingFaceEndpoint,
-    Ollama,
-    OpenAI,
-)
+from common.config import get_graphrag_config, embedding_service
 
-def get_chunker(chunker_type: str = ""):
+def get_chunker(chunker_type: str = "", graphname: str = None):
+    cfg = get_graphrag_config(graphname)
     if not chunker_type:
-        chunker_type = graphrag_config.get("chunker", "semantic")
-    chunker_config = graphrag_config.get("chunker_config", {})
+        chunker_type = cfg.get("chunker", "semantic")
+    chunker_config = cfg.get("chunker_config", {})
     if chunker_type == "semantic":
         chunker = semantic_chunker.SemanticChunker(
             embedding_service,
@@ -55,26 +45,3 @@ def get_chunker(chunker_type: str = ""):
         raise ValueError(f"Invalid chunker type: {chunker_type}")
 
     return chunker
-
-
-def get_llm_service():
-    if llm_config["completion_service"]["llm_service"].lower() == "openai":
-        llm_provider = OpenAI(llm_config["completion_service"])
-    elif llm_config["completion_service"]["llm_service"].lower() == "azure":
-        llm_provider = AzureOpenAI(llm_config["completion_service"])
-    elif llm_config["completion_service"]["llm_service"].lower() == "sagemaker":
-        llm_provider = AWS_SageMaker_Endpoint(llm_config["completion_service"])
-    elif llm_config["completion_service"]["llm_service"].lower() == "vertexai":
-        llm_provider = GoogleVertexAI(llm_config["completion_service"])
-    elif llm_config["completion_service"]["llm_service"].lower() == "genai":
-        llm_provider = GoogleGenAI(llm_config["completion_service"])
-    elif llm_config["completion_service"]["llm_service"].lower() == "bedrock":
-        llm_provider = AWSBedrock(llm_config["completion_service"])
-    elif llm_config["completion_service"]["llm_service"].lower() == "groq":
-        llm_provider = Groq(llm_config["completion_service"])
-    elif llm_config["completion_service"]["llm_service"].lower() == "ollama":
-        llm_provider = Ollama(llm_config["completion_service"])
-    elif llm_config["completion_service"]["llm_service"].lower() == "huggingface":
-        llm_provider = HuggingFaceEndpoint(llm_config["completion_service"])
-
-    return llm_provider
diff --git a/ecc/app/eventual_consistency_checker.py b/ecc/app/eventual_consistency_checker.py
index 499bdc7..1c28b53 100644
--- a/ecc/app/eventual_consistency_checker.py
+++ b/ecc/app/eventual_consistency_checker.py
@@ -91,7 +91,7 @@ def _check_query_install(self, query_name):
             return True
 
     def _chunk_document(self, content):
-        chunker = ecc_util.get_chunker(content["ctype"])
+        chunker = ecc_util.get_chunker(content["ctype"], graphname=self.graphname)
         return chunker.chunk(content["text"])
 
     def _extract_entities(self, content):
diff --git a/ecc/app/graphrag/community_summarizer.py b/ecc/app/graphrag/community_summarizer.py
index 0bab35b..532b94f 100644
--- a/ecc/app/graphrag/community_summarizer.py
+++ b/ecc/app/graphrag/community_summarizer.py
@@ -13,25 +13,18 @@
 # limitations under the License.
 
 import re
+import logging
 
 from langchain_core.prompts import PromptTemplate
+from langchain_core.output_parsers import PydanticOutputParser
 
 from common.llm_services import LLM_Model
 from common.py_schemas import CommunitySummary
 
+logger = logging.getLogger(__name__)
+
+
 # src: https://github.com/microsoft/graphrag/blob/main/graphrag/index/graph/extractors/summarize/prompts.py
-SUMMARIZE_PROMPT = PromptTemplate.from_template("""
-You are a helpful assistant responsible for generating a comprehensive summary of the data provided below.
-Given one or two entities, and a list of descriptions, all related to the same entity or group of entities.
-Please concatenate all of these into a single, comprehensive description. Make sure to include information collected from all the descriptions.
-If the provided descriptions are contradictory, please resolve the contradictions and provide a single, coherent summary, but do not add any information that is not in the description.
-Make sure it is written in third person, and include the entity names so we the have full context.
-
-#######
--Data-
-Commuinty Title: {entity_name}
-Description List: {description_list}
-""")
 
 id_pat = re.compile(r"[_\d]*")
 
@@ -43,19 +36,22 @@ def __init__(
     ):
         self.llm_service = llm_service
 
-    async def summarize(self, name: str, text: list[str]) -> CommunitySummary:
-        structured_llm = self.llm_service.model.with_structured_output(CommunitySummary)
-        chain = SUMMARIZE_PROMPT | structured_llm
+    async def summarize(self, name: str, text: list[str]) -> dict:
+        summary_parser = PydanticOutputParser(pydantic_object=CommunitySummary)
+        prompt = PromptTemplate(
+            template=self.llm_service.community_summarize_prompt + "\n{format_instructions}",
+            input_variables=["entity_name", "description_list"],
+            partial_variables={"format_instructions": summary_parser.get_format_instructions()},
+        )
 
         # remove iteration tags from name
         name = id_pat.sub("", name)
         try:
-            summary = await chain.ainvoke(
-                {
-                    "entity_name": name,
-                    "description_list": text,
-                }
+            summary = await self.llm_service.ainvoke_with_parser(
+                prompt, summary_parser,
+                {"entity_name": name, "description_list": text},
+                caller_name="community_summarize",
             )
         except Exception as e:
             return {"error": True, "summary": "", "message": str(e)}
-        return {"error": False, "summary": summary.summary}
+        return {"error": False, "summary": summary.summary}
\ No newline at end of file
diff --git a/ecc/app/graphrag/graph_rag.py b/ecc/app/graphrag/graph_rag.py
index 5544789..49a5760 100644
--- a/ecc/app/graphrag/graph_rag.py
+++ b/ecc/app/graphrag/graph_rag.py
@@ -36,7 +36,7 @@
 )
 from pyTigerGraph import AsyncTigerGraphConnection
 
-from common.config import embedding_service, graphrag_config, entity_extraction_switch, community_detection_switch, doc_process_switch
+from common.config import embedding_service, entity_extraction_switch, community_detection_switch, doc_process_switch, get_graphrag_config
 from common.embeddings.base_embedding_store import EmbeddingStore
 from common.extractors.BaseExtractor import BaseExtractor
 
@@ -179,8 +179,9 @@ async def upsert(upsert_chan: Channel):
 async def load(conn: AsyncTigerGraphConnection):
     logger.info("Data Loading Start")
     dd = lambda: defaultdict(dd)  # infinite default dict
-    batch_size = graphrag_config.get("load_batch_size", 500)
-    upsert_delay = graphrag_config.get("upsert_delay", 0)
+    graph_cfg = get_graphrag_config(conn.graphname)
+    batch_size = graph_cfg.get("load_batch_size", 500)
+    upsert_delay = graph_cfg.get("upsert_delay", 0)
     # while the load q is still open or has contents
     while not load_q.closed() or not load_q.empty():
         if load_q.closed():
@@ -259,7 +260,7 @@ async def embed(
                 (v_id, content, index_name) = await embed_chan.get()
                 v_id = (v_id, index_name)
                 logger.info(f"Embed to {graphname}_{index_name}: {v_id}")
-                if graphrag_config.get("reuse_embedding", True) and embedding_store.has_embeddings([v_id]):
+                if get_graphrag_config(graphname).get("reuse_embedding", True) and embedding_store.has_embeddings([v_id]):
                     logger.info(f"Embeddings for {v_id} already exists, skipping to save cost")
                     continue
                 grp.create_task(
diff --git a/ecc/app/graphrag/util.py b/ecc/app/graphrag/util.py
index f581057..f12157f 100644
--- a/ecc/app/graphrag/util.py
+++ b/ecc/app/graphrag/util.py
@@ -28,7 +28,8 @@
     graphrag_config,
     embedding_service,
     get_llm_service,
-    llm_config,
+    get_completion_config,
+    get_graphrag_config,
 )
 from common.embeddings.base_embedding_store import EmbeddingStore
 from common.embeddings.tigergraph_embedding_store import TigerGraphEmbeddingStore
@@ -40,7 +41,11 @@
 
 http_timeout = httpx.Timeout(15.0)
 
-tg_sem = asyncio.Semaphore(graphrag_config.get("tg_concurrency", 10))
+_default_concurrency = graphrag_config.get("default_concurrency", 10)
+# Worker amplifier: processing workers (chunk, embed, extract, community) run at 2x
+# the base concurrency since each worker is mostly waiting on I/O (LLM/embedding API calls).
+_worker_concurrency = _default_concurrency * 2
+tg_sem = asyncio.Semaphore(_default_concurrency)
 load_q = reusable_channel.ReuseableChannel()
 
 # will pause workers until the event is false
@@ -132,10 +137,11 @@ async def init(
     await install_queries(requried_queries, conn)
 
     # extractor
-    if graphrag_config.get("extractor") == "graphrag":
+    graph_cfg = get_graphrag_config(conn.graphname)
+    if graph_cfg.get("extractor") == "graphrag":
         extractor = GraphExtractor()
-    elif graphrag_config.get("extractor") == "llm":
-        extractor = LLMEntityRelationshipExtractor(get_llm_service(llm_config))
+    elif graph_cfg.get("extractor") == "llm":
+        extractor = LLMEntityRelationshipExtractor(get_llm_service(get_completion_config()))
     else:
         raise ValueError("Invalid extractor type")
 
diff --git a/ecc/app/graphrag/workers.py b/ecc/app/graphrag/workers.py
index 78f38be..c0b35cc 100644
--- a/ecc/app/graphrag/workers.py
+++ b/ecc/app/graphrag/workers.py
@@ -64,7 +64,7 @@ async def install_query(
     return {"result": res, "error": False}
 
 
-chunk_sem = asyncio.Semaphore(20)
+chunk_sem = asyncio.Semaphore(util._worker_concurrency)
 
 
 async def chunk_doc(
@@ -98,7 +98,7 @@ async def chunk_doc(
         
         # Use get_chunker for all types (including images)
         # For images, get_chunker returns SingleChunker which preserves markdown image references
-        chunker = ecc_util.get_chunker(chunker_type)
+        chunker = ecc_util.get_chunker(chunker_type, graphname=conn.graphname)
         # decode the text return from tigergraph as it was encoded when written into jsonl file for uploading
         chunks = chunker.chunk(doc["attributes"]["text"].encode('raw_unicode_escape').decode('unicode_escape'))
        
@@ -172,7 +172,7 @@ async def upsert_chunk(conn: AsyncTigerGraphConnection, doc_id, chunk_id, chunk)
         )
 
 
-embed_sem = asyncio.Semaphore(20)
+embed_sem = asyncio.Semaphore(util._worker_concurrency)
 
 
 async def embed(
@@ -220,7 +220,7 @@ async def get_vert_desc(conn, v_id, node: Node):
     return desc
 
 
-extract_sem = asyncio.Semaphore(20)
+extract_sem = asyncio.Semaphore(util._worker_concurrency)
 
 
 async def extract(
@@ -406,7 +406,7 @@ async def extract(
                 # right now, we're not embedding relationships in graphrag
 
 
-comm_sem = asyncio.Semaphore(20)
+comm_sem = asyncio.Semaphore(util._worker_concurrency)
 
 
 async def process_community(
@@ -440,7 +440,8 @@ async def process_community(
         if len(children) == 1:
             summary = children[0]
         else:
-            llm = ecc_util.get_llm_service()
+            from common.config import get_llm_service, get_completion_config
+            llm = get_llm_service(get_completion_config(conn.graphname))
             summarizer = community_summarizer.CommunitySummarizer(llm)
             summary = await summarizer.summarize(comm_id, children)
             if summary["error"]:
diff --git a/ecc/app/main.py b/ecc/app/main.py
index 5468391..0db691b 100644
--- a/ecc/app/main.py
+++ b/ecc/app/main.py
@@ -36,6 +36,9 @@
     embedding_service,
     get_llm_service,
     llm_config,
+    get_completion_config,
+    get_graphrag_config,
+    reload_db_config,
 )
 from common.db.connections import elevate_db_connection_to_token, get_db_connection_id_token
 from common.embeddings.base_embedding_store import EmbeddingStore
@@ -97,28 +100,29 @@ def initialize_eventual_consistency_checker(
                 embedding_service,
                 support_ai_instance=False,
             )
-        index_names = graphrag_config.get(
+        graph_cfg = get_graphrag_config(graphname)
+        index_names = graph_cfg.get(
             "indexes",
             ["DocumentChunk", "Community"],
         )
 
-        if graphrag_config.get("extractor") == "llm":
+        if graph_cfg.get("extractor") == "llm":
             from common.extractors import LLMEntityRelationshipExtractor
 
-            extractor = LLMEntityRelationshipExtractor(get_llm_service(llm_config))
+            extractor = LLMEntityRelationshipExtractor(get_llm_service(get_completion_config()))
         else:
             raise ValueError("Invalid extractor type")
 
         checker = EventualConsistencyChecker(
-            graphrag_config.get("process_interval_seconds", 300),
-            graphrag_config.get("cleanup_interval_seconds", 300),
+            graph_cfg.get("process_interval_seconds", 300),
+            graph_cfg.get("cleanup_interval_seconds", 300),
             graphname,
             embedding_service,
             embedding_store,
             index_names,
             conn,
             extractor,
-            graphrag_config.get("batch_size", 100),
+            graph_cfg.get("checker_batch_size", graph_cfg.get("batch_size", 100)),
         )
         consistency_checkers[graphname] = checker
 
@@ -213,6 +217,41 @@ async def run_with_tracking(task_key: str, run_func, graphname: str, conn):
     try:
         running_tasks[task_key] = {"status": "running", "started_at": time.time()}
         LogWriter.info(f"Starting ECC task: {task_key}")
+        
+        # Reload config at the start of each job to ensure latest settings are used
+        LogWriter.info("Reloading configuration for new job...")
+        from common.config import reload_llm_config, reload_graphrag_config, reload_db_config
+
+        llm_result = reload_llm_config()
+        if llm_result["status"] == "success":
+            LogWriter.info(f"LLM config reloaded: {llm_result['message']}")
+            completion_service = llm_config.get("completion_service", {})
+            ecc_model = completion_service.get("llm_model", "unknown")
+            ecc_provider = completion_service.get("llm_service", "unknown")
+            LogWriter.info(
+                f"[ECC] Using completion model={ecc_model} (provider={ecc_provider})"
+            )
+        else:
+            LogWriter.warning(f"LLM config reload had issues: {llm_result['message']}")
+
+        db_result = reload_db_config()
+        if db_result["status"] == "success":
+            LogWriter.info(
+                f"DB config reloaded: {db_result['message']} "
+                f"(host={db_config.get('hostname')}, "
+                f"restppPort={db_config.get('restppPort')}, "
+                f"gsPort={db_config.get('gsPort')})"
+            )
+        else:
+            LogWriter.warning(f"DB config reload had issues: {db_result['message']}")
+
+        graphrag_result = reload_graphrag_config()
+        if graphrag_result["status"] == "success":
+            LogWriter.info(f"GraphRAG config reloaded: {graphrag_result['message']}")
+        else:
+            LogWriter.warning(f"GraphRAG config reload had issues: {graphrag_result['message']}")
+        
+        # Now run the actual job with fresh config
         await run_func(graphname, conn)
         running_tasks[task_key] = {"status": "completed", "completed_at": time.time()}
         LogWriter.info(f"Completed ECC task: {task_key}")
@@ -242,6 +281,17 @@ def consistency_update(
     response: Response,
     credentials = Depends(auth_credentials),
 ):
+    db_result = reload_db_config()
+    if db_result["status"] == "success":
+        LogWriter.info(
+            f"DB config reloaded: {db_result['message']} "
+            f"(host={db_config.get('hostname')}, "
+            f"restppPort={db_config.get('restppPort')}, "
+            f"gsPort={db_config.get('gsPort')})"
+        )
+    else:
+        LogWriter.warning(f"DB config reload had issues: {db_result['message']}")
+
     if isinstance(credentials, HTTPBasicCredentials):
         conn = elevate_db_connection_to_token(
             db_config.get("hostname"),
diff --git a/ecc/app/supportai/util.py b/ecc/app/supportai/util.py
index d3906ca..6269624 100644
--- a/ecc/app/supportai/util.py
+++ b/ecc/app/supportai/util.py
@@ -12,10 +12,11 @@
 from pyTigerGraph import TigerGraphConnection
 
 from common.config import (
-    graphrag_config,
     embedding_service,
+    graphrag_config,
     get_llm_service,
-    llm_config,
+    get_completion_config,
+    get_graphrag_config,
 )
 from common.embeddings.base_embedding_store import EmbeddingStore
 from common.embeddings.tigergraph_embedding_store import TigerGraphEmbeddingStore
@@ -26,7 +27,8 @@
 logger = logging.getLogger(__name__)
 http_timeout = httpx.Timeout(15.0)
 
-tg_sem = asyncio.Semaphore(100)
+_default_concurrency = graphrag_config.get("default_concurrency", 10)
+tg_sem = asyncio.Semaphore(_default_concurrency * 2)
 
 async def install_queries(
     requried_queries: list[str],
@@ -109,10 +111,11 @@ async def init(
     await install_queries(requried_queries, conn)
 
     # extractor
-    if graphrag_config.get("extractor") == "graphrag":
+    graph_cfg = get_graphrag_config(conn.graphname)
+    if graph_cfg.get("extractor") == "graphrag":
         extractor = GraphExtractor()
-    elif graphrag_config.get("extractor") == "llm":
-        extractor = LLMEntityRelationshipExtractor(get_llm_service(llm_config))
+    elif graph_cfg.get("extractor") == "llm":
+        extractor = LLMEntityRelationshipExtractor(get_llm_service(get_completion_config()))
     else:
         raise ValueError("Invalid extractor type")
 
diff --git a/ecc/app/supportai/workers.py b/ecc/app/supportai/workers.py
index 30fc9ab..2c62169 100644
--- a/ecc/app/supportai/workers.py
+++ b/ecc/app/supportai/workers.py
@@ -85,7 +85,7 @@ async def chunk_doc(
     
     # Use markdown chunker for all documents
     # Image descriptions wrapped in headers will naturally become single chunks
-    chunker = ecc_util.get_chunker(chunker_type)
+    chunker = ecc_util.get_chunker(chunker_type, graphname=conn.graphname)
     chunks = chunker.chunk(doc["attributes"]["text"])
     
     logger.info(f"Chunking {v_id} into {len(chunks)} chunk(s)")
diff --git a/graphrag-ui/Dockerfile b/graphrag-ui/Dockerfile
index 9dc17e6..aec0713 100644
--- a/graphrag-ui/Dockerfile
+++ b/graphrag-ui/Dockerfile
@@ -12,4 +12,4 @@ RUN pnpm run build
 RUN pnpm i -g serve
 
 
-CMD [ "serve", "dist" ]
+CMD [ "serve", "-s", "dist" ]
diff --git a/graphrag-ui/src/actions/ActionProvider.tsx b/graphrag-ui/src/actions/ActionProvider.tsx
index d12c9f7..58fc7aa 100644
--- a/graphrag-ui/src/actions/ActionProvider.tsx
+++ b/graphrag-ui/src/actions/ActionProvider.tsx
@@ -55,8 +55,8 @@ const conversationManager = {
     if (onNewConversationCallback) {
       onNewConversationCallback();
     }
-    // Clear conversation data from localStorage
-    localStorage.removeItem('selectedConversationData');
+    // Clear conversation data from sessionStorage
+    sessionStorage.removeItem('selectedConversationData');
     // Don't reload the page - just clear the chat state
   },
 
@@ -88,7 +88,7 @@ const ActionProvider: React.FC<ActionProviderProps> = ({
   const { sendMessage, lastMessage, readyState } = useWebSocket(WS_URL, {
     onOpen: () => {
       // Send authentication credentials
-      const creds = localStorage.getItem("creds");
+      const creds = sessionStorage.getItem("creds");
       console.log("Sending credentials, length:", creds ? creds.length : 0);
       queryGraphragWs2(creds!);
 
@@ -115,7 +115,7 @@ const ActionProvider: React.FC<ActionProviderProps> = ({
 
   // Initialize conversation manager and load conversation messages
   useEffect(() => {
-    const selectedConversationData = localStorage.getItem('selectedConversationData');
+    const selectedConversationData = sessionStorage.getItem('selectedConversationData');
     if (selectedConversationData) {
       try {
         const data = JSON.parse(selectedConversationData);
@@ -163,7 +163,7 @@ const ActionProvider: React.FC<ActionProviderProps> = ({
             // Create bot message
             const botMessage = createChatBotMessage({
               content: msg.content || "",
-              response_type: msg.response_type || "text",
+              response_type: "history",
               query_sources: msg.query_sources,
               answered_question: msg.answered_question,
             });
diff --git a/graphrag-ui/src/components/Bot.tsx b/graphrag-ui/src/components/Bot.tsx
index 1f4e4e6..6386dec 100644
--- a/graphrag-ui/src/components/Bot.tsx
+++ b/graphrag-ui/src/components/Bot.tsx
@@ -22,15 +22,15 @@ import {
 const Bot = ({ layout, getConversationId }: { layout?: string | undefined, getConversationId?:any }) => {
   const [store, setStore] = useState<any>();
   const [currentDate, setCurrentDate] = useState('');
-  const [selectedGraph, setSelectedGraph] = useState(localStorage.getItem("selectedGraph") || '');
-  const [ragPattern, setRagPattern] = useState(localStorage.getItem("ragPattern") || '');
+  const [selectedGraph, setSelectedGraph] = useState(sessionStorage.getItem("selectedGraph") || '');
+  const [ragPattern, setRagPattern] = useState(sessionStorage.getItem("ragPattern") || '');
   const navigate = useNavigate();
   const location = useLocation();
 
   useEffect(() => {
-    // Function to load store from localStorage
+    // Function to load store from sessionStorage
     const loadStore = () => {
-      const parseStore = JSON.parse(localStorage.getItem("site") || "{}");
+      const parseStore = JSON.parse(sessionStorage.getItem("site") || "{}");
       setStore(parseStore);
       return parseStore;
     };
@@ -39,23 +39,23 @@ const Bot = ({ layout, getConversationId }: { layout?: string | undefined, getCo
     const parseStore = loadStore();
 
     // Validate selectedGraph against the current graph list
-    const storedGraph = localStorage.getItem("selectedGraph");
+    const storedGraph = sessionStorage.getItem("selectedGraph");
     const availableGraphs = parseStore?.graphs || [];
     if (!storedGraph || !availableGraphs.includes(storedGraph)) {
       if (availableGraphs.length > 0) {
         const firstGraph = availableGraphs[0];
         setSelectedGraph(firstGraph);
-        localStorage.setItem("selectedGraph", firstGraph);
+        sessionStorage.setItem("selectedGraph", firstGraph);
       } else {
         setSelectedGraph('');
-        localStorage.removeItem("selectedGraph");
+        sessionStorage.removeItem("selectedGraph");
       }
     }
 
-    // Set default ragPattern if no value in localStorage
-    if (!localStorage.getItem("ragPattern")) {
+    // Set default ragPattern if no value in sessionStorage
+    if (!sessionStorage.getItem("ragPattern")) {
       setRagPattern("Hybrid Search");
-      localStorage.setItem("ragPattern", "Hybrid Search");
+      sessionStorage.setItem("ragPattern", "Hybrid Search");
     }
 
     const date = new Date();
@@ -78,20 +78,21 @@ const Bot = ({ layout, getConversationId }: { layout?: string | undefined, getCo
 
   // Reload graph list when navigating back to chat (location change)
   useEffect(() => {
-    const parseStore = JSON.parse(localStorage.getItem("site") || "{}");
+    const parseStore = JSON.parse(sessionStorage.getItem("site") || "{}");
     setStore(parseStore);
   }, [location]);
 
   const handleSelect = (value) => {
     setSelectedGraph(value);
-    localStorage.setItem("selectedGraph", value);
+    sessionStorage.setItem("selectedGraph", value);
+    window.dispatchEvent(new Event("graphrag:selectedGraph"));
     navigate("/chat");
     //window.location.reload();
   };
 
   const handleSelectRag = (value) => {
     setRagPattern(value);
-    localStorage.setItem("ragPattern", value);
+    sessionStorage.setItem("ragPattern", value);
     navigate("/chat");
     //window.location.reload();
   };
diff --git a/graphrag-ui/src/components/ConfigScopeToggle.tsx b/graphrag-ui/src/components/ConfigScopeToggle.tsx
new file mode 100644
index 0000000..b311631
--- /dev/null
+++ b/graphrag-ui/src/components/ConfigScopeToggle.tsx
@@ -0,0 +1,100 @@
+import React from "react";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+
+interface ConfigScopeToggleProps {
+  configScope: "global" | "graph";
+  selectedGraph: string;
+  availableGraphs: string[];
+  onScopeChange: (scope: "global" | "graph") => void;
+  onGraphChange: (graph: string) => void;
+  /** Optional hint rendered below the toggle when graph scope is active and a graph is selected */
+  graphSelectedHint?: React.ReactNode;
+  /** CSS class for the outer wrapper (e.g. "mb-6") */
+  className?: string;
+  /** When true, hides the "Edit global defaults" option and forces graph-specific scope */
+  graphOnly?: boolean;
+}
+
+const ConfigScopeToggle: React.FC<ConfigScopeToggleProps> = ({
+  configScope,
+  selectedGraph,
+  availableGraphs,
+  onScopeChange,
+  onGraphChange,
+  graphSelectedHint,
+  className = "mb-6",
+  graphOnly = false,
+}) => {
+  if (availableGraphs.length === 0) return null;
+
+  return (
+    <div className={`bg-white dark:bg-shadeA border border-gray-300 dark:border-[#3D3D3D] rounded-lg p-6 ${className}`}>
+      <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+        Configuration Scope
+      </label>
+      <div className="flex items-center gap-4">
+        {!graphOnly && (
+          <label className="flex items-center gap-2 cursor-pointer">
+            <input
+              type="radio"
+              name="configScopeToggle"
+              checked={configScope === "global"}
+              onChange={() => onScopeChange("global")}
+              className="h-4 w-4"
+            />
+            <span className="text-sm text-black dark:text-white">Edit global defaults</span>
+          </label>
+        )}
+        {!graphOnly && (
+          <label className="flex items-center gap-2 cursor-pointer">
+            <input
+              type="radio"
+              name="configScopeToggle"
+              checked={configScope === "graph"}
+              onChange={() => onScopeChange("graph")}
+              className="h-4 w-4"
+            />
+            <span className="text-sm text-black dark:text-white">Edit graph-specific config for</span>
+          </label>
+        )}
+        {graphOnly && (
+          <span className="text-sm text-black dark:text-white">Edit graph-specific config for</span>
+        )}
+        <Select
+          value={selectedGraph}
+          disabled={configScope !== "graph"}
+          onValueChange={(value) => onGraphChange(value)}
+        >
+          <SelectTrigger className="w-48 dark:border-[#3D3D3D] dark:bg-background">
+            <SelectValue placeholder="Select a graph" />
+          </SelectTrigger>
+          <SelectContent>
+            {availableGraphs.map((graph) => (
+              <SelectItem key={graph} value={graph}>
+                {graph}
+              </SelectItem>
+            ))}
+          </SelectContent>
+        </Select>
+      </div>
+      {configScope === "graph" && !selectedGraph && (
+        <p className="text-xs text-amber-600 dark:text-amber-400 mt-2">
+          Please select a graph to edit its configuration.
+        </p>
+      )}
+      {configScope === "graph" && selectedGraph && graphSelectedHint && (
+        <div className="text-xs text-gray-500 dark:text-gray-400 mt-2">
+          {graphSelectedHint}
+        </div>
+      )}
+    </div>
+  );
+};
+
+export default ConfigScopeToggle;
diff --git a/graphrag-ui/src/components/CustomChatMessage.tsx b/graphrag-ui/src/components/CustomChatMessage.tsx
index 9c2c5ee..0aef2ea 100755
--- a/graphrag-ui/src/components/CustomChatMessage.tsx
+++ b/graphrag-ui/src/components/CustomChatMessage.tsx
@@ -60,10 +60,10 @@ const AuthenticatedImage: FC<{ src: string; alt: string }> = ({ src, alt }) => {
   useEffect(() => {
     const fetchImage = async () => {
       try {
-        // Get credentials from localStorage (same pattern as Interact.tsx and SideMenu.tsx)
-        const creds = localStorage.getItem("creds");
+        // Get credentials from sessionStorage (same pattern as Interact.tsx and SideMenu.tsx)
+        const creds = sessionStorage.getItem("creds");
         if (!creds) {
-          console.error("No credentials found in localStorage");
+          console.error("No credentials found in sessionStorage");
           setError(true);
           setLoading(false);
           return;
@@ -173,7 +173,7 @@ export const CustomChatMessage: FC<IChatbotMessageProps> = ({
     <>
       {typeof message === "string" ? (
         <div className="prose dark:prose-invert text-sm max-w-[230px] md:max-w-[80%] mt-7 mb-7">
-          <ReactMarkdown remarkPlugins={[remarkGfm]} components={markdownComponents} className="typewriter">{message}</ReactMarkdown>
+          <ReactMarkdown remarkPlugins={[remarkGfm]} components={markdownComponents}>{message}</ReactMarkdown>
         </div>
       ) : message.key === null ? (
         message
@@ -181,9 +181,9 @@ export const CustomChatMessage: FC<IChatbotMessageProps> = ({
         <div className="flex flex-col w-full relative">
           <div className="prose dark:prose-invert text-sm w-full mt-7 mb-7">
             {message.response_type === "progress" ? (
-              <p className="graphrag-thinking typewriter">{message.content}</p>
+              <p className={`graphrag-thinking${message.response_type !== "history" ? " typewriter" : ""}`}>{message.content}</p>
             ) : (
-              <ReactMarkdown remarkPlugins={[remarkGfm]} components={markdownComponents} className="typewriter">{message.content}</ReactMarkdown>
+              <ReactMarkdown remarkPlugins={[remarkGfm]} components={markdownComponents} className={message.response_type === "history" ? undefined : "typewriter"}>{message.content}</ReactMarkdown>
             )}
             <Interactions
               message={message} 
diff --git a/graphrag-ui/src/components/Interact.tsx b/graphrag-ui/src/components/Interact.tsx
index 3d13a61..e1426f0 100644
--- a/graphrag-ui/src/components/Interact.tsx
+++ b/graphrag-ui/src/components/Interact.tsx
@@ -29,7 +29,7 @@ export const Interactions: FC<Interactions> = ({
   const [feedback, setFeedback] = useState(Feedback.NoFeedback);
 
   const sendFeedback = async (action: Feedback, message: Message) => {
-    const creds = localStorage.getItem("creds");
+    const creds = sessionStorage.getItem("creds");
     setFeedback(action);
     message.feedback = action;
     await fetch(`${GRAPHRAG_URL}/ui/feedback`, {
diff --git a/graphrag-ui/src/components/Login.tsx b/graphrag-ui/src/components/Login.tsx
index 5455f08..d753124 100644
--- a/graphrag-ui/src/components/Login.tsx
+++ b/graphrag-ui/src/components/Login.tsx
@@ -36,12 +36,12 @@ const WS_URL = "/ui/ui-login";
 export function Login() {
   const { i18n, t } = useTranslation();
   const [user, setUser] = useState("");
-  const [token, setToken] = useState(localStorage.getItem("site") || "");
+  const [token, setToken] = useState(sessionStorage.getItem("site") || "");
   const [hint, setHint] = useState("");
   const navigate = useNavigate();
 
   useEffect(() => {
-    const parseStore = JSON.parse(localStorage.getItem("site") || "{}");
+    const parseStore = JSON.parse(sessionStorage.getItem("site") || "{}");
     setToken(parseStore);
   }, []);
 
@@ -49,23 +49,30 @@ export function Login() {
     const creds = btoa(`${data.email}:${data.password}`);
     const username = data.email;
 
-    const res = await fetch("/ui/ui-login", {
+    try {
+      const res = await fetch("/ui/ui-login", {
         method: "POST",
         headers: {
-        Authorization: `Basic ${creds}`,
+          Authorization: `Basic ${creds}`,
         },
       });
 
-    if (res.ok) {
-      const data = await res.json();
-      localStorage.setItem("creds", creds);
-      localStorage.setItem("site", JSON.stringify(data));
-      setUser(username);
-      localStorage.setItem("username", username);
-      navigate("/chat");
-    } else {
-      // setError("Invalid credentials"); // This line was removed from the new_code, so it's removed here.
-      setHint("Invalid credentials");
+      if (res.ok) {
+        const data = await res.json();
+        sessionStorage.setItem("creds", creds);
+        sessionStorage.setItem("site", JSON.stringify(data));
+        setUser(username);
+        sessionStorage.setItem("username", username);
+        navigate("/chat");
+      } else if (res.status === 401 || res.status === 403) {
+        setHint("Invalid credentials");
+        navigate("/");
+      } else {
+        setHint(`Server error (${res.status}). Please try again later.`);
+        navigate("/");
+      }
+    } catch {
+      setHint("Unable to connect to the server. Please try again later.");
       navigate("/");
     }
   };
@@ -73,7 +80,7 @@ export function Login() {
   const logOut = () => {
     setUser("");
     setToken("");
-    localStorage.removeItem("site");
+    sessionStorage.removeItem("site");
     navigate("/");
   };
 
diff --git a/graphrag-ui/src/components/ModeToggle.tsx b/graphrag-ui/src/components/ModeToggle.tsx
index a8109bc..053ac9f 100644
--- a/graphrag-ui/src/components/ModeToggle.tsx
+++ b/graphrag-ui/src/components/ModeToggle.tsx
@@ -10,6 +10,7 @@ import {
 } from "@/components/ui/dropdown-menu";
 import { useTheme } from "@/components/ThemeProvider";
 import { useConfirm } from "@/hooks/useConfirm";
+import { useRoles } from "@/hooks/useRoles";
 
 export function ModeToggle() {
   const { setTheme } = useTheme();
@@ -17,6 +18,7 @@ export function ModeToggle() {
   const location = useLocation();
   const isLoginRoute = location.pathname === "/";
   const [confirm, confirmDialog] = useConfirm();
+  const { rolesLoaded, canAccessSetup } = useRoles(location.pathname);
 
   const handleLogout = async () => {
     // Show confirmation dialog
@@ -46,7 +48,7 @@ export function ModeToggle() {
 
   return (
     <div className="absolute right-4 top-[13px] flex items-center gap-2">
-      {!isLoginRoute && (
+      {!isLoginRoute && rolesLoaded && canAccessSetup && (
         <Button 
           variant="outline" 
           className="dark:border-[#3D3D3D]"
@@ -57,14 +59,16 @@ export function ModeToggle() {
         </Button>
       )}
       
-      <Button 
-        variant="outline" 
-        className="dark:border-[#3D3D3D]"
-        onClick={handleLogout}
-        title="Logout"
-      >
-        <LogOut className="h-[1rem] w-[1rem]" />
-      </Button>
+      {!isLoginRoute && (
+        <Button 
+          variant="outline" 
+          className="dark:border-[#3D3D3D]"
+          onClick={handleLogout}
+          title="Logout"
+        >
+          <LogOut className="h-[1rem] w-[1rem]" />
+        </Button>
+      )}
       
       <DropdownMenu>
         <DropdownMenuTrigger asChild>
diff --git a/graphrag-ui/src/components/SideMenu.tsx b/graphrag-ui/src/components/SideMenu.tsx
index a1980b5..c4072db 100644
--- a/graphrag-ui/src/components/SideMenu.tsx
+++ b/graphrag-ui/src/components/SideMenu.tsx
@@ -72,8 +72,8 @@ const SideMenu = ({ height, setGetConversationId }: { height?: string, setGetCon
 
   const fetchHistory2 = useCallback(async () => {
     setConversationId([]);
-    const creds = localStorage.getItem("creds");
-    const username = localStorage.getItem("username");
+    const creds = sessionStorage.getItem("creds");
+    const username = sessionStorage.getItem("username");
 
     if (!username) {
       return;
@@ -165,7 +165,7 @@ const SideMenu = ({ height, setGetConversationId }: { height?: string, setGetCon
   const handleNewChat = () => {
     conversationManager.startNewConversation();
     // Clear any selected conversation data
-    localStorage.removeItem('selectedConversationData');
+    sessionStorage.removeItem('selectedConversationData');
     // Force navigation by reloading if already on chat page
     if (window.location.pathname === "/chat") {
       window.location.reload();
@@ -186,7 +186,7 @@ const SideMenu = ({ height, setGetConversationId }: { height?: string, setGetCon
       setExpandedConversations(prev => new Set([...prev, id]));
 
       // Store conversation data for the chat component
-      const creds = localStorage.getItem("creds");
+      const creds = sessionStorage.getItem("creds");
       if (!creds) {
         return;
       }
@@ -207,8 +207,8 @@ const SideMenu = ({ height, setGetConversationId }: { height?: string, setGetCon
       const data = await response.json();
       setConversationId2(data);
 
-      // Store the conversation data in localStorage for the chat component
-      localStorage.setItem('selectedConversationData', JSON.stringify(data));
+      // Store the conversation data in sessionStorage for the chat component
+      sessionStorage.setItem('selectedConversationData', JSON.stringify(data));
 
       // Force reload to restart the WebSocket connection with the conversation ID
       // This ensures the Bot component re-initializes and loads the conversation messages
diff --git a/graphrag-ui/src/components/Start.tsx b/graphrag-ui/src/components/Start.tsx
index 6ddd927..2746932 100644
--- a/graphrag-ui/src/components/Start.tsx
+++ b/graphrag-ui/src/components/Start.tsx
@@ -4,7 +4,7 @@ import { useTheme } from "@/components/ThemeProvider";
 
 
 const questions = (() => {
-  const selectedGraph = localStorage.getItem('selectedGraph');
+  const selectedGraph = sessionStorage.getItem('selectedGraph');
 
   if (selectedGraph?.includes('pyTigerGraphRAG') || selectedGraph?.includes('pyTG')) {
     return [
diff --git a/graphrag-ui/src/hooks/AuthProvider.tsx b/graphrag-ui/src/hooks/AuthProvider.tsx
index e2a32ea..c64006e 100644
--- a/graphrag-ui/src/hooks/AuthProvider.tsx
+++ b/graphrag-ui/src/hooks/AuthProvider.tsx
@@ -8,7 +8,7 @@ const AuthContext = createContext();
 
 const AuthProvider = ({ children }) => {
   const [user, setUser] = useState("");
-  const [token, setToken] = useState(localStorage.getItem("site") || "");
+  const [token, setToken] = useState(sessionStorage.getItem("site") || "");
   const navigate = useNavigate();
   const loginAction = async (data) => {
     try {
@@ -23,7 +23,7 @@ const AuthProvider = ({ children }) => {
       if (res.data) {
         setUser(res.data.user);
         setToken(res.token);
-        localStorage.setItem("site", res.token);
+        sessionStorage.setItem("site", res.token);
         navigate("/dashboard");
         return;
       }
@@ -36,7 +36,7 @@ const AuthProvider = ({ children }) => {
   const logOut = () => {
     setUser("");
     setToken("");
-    localStorage.removeItem("site");
+    sessionStorage.removeItem("site");
     navigate("/login");
   };
 
diff --git a/graphrag-ui/src/hooks/useIdleTimeout.ts b/graphrag-ui/src/hooks/useIdleTimeout.ts
new file mode 100644
index 0000000..07f0486
--- /dev/null
+++ b/graphrag-ui/src/hooks/useIdleTimeout.ts
@@ -0,0 +1,72 @@
+import { useEffect, useRef, useCallback } from "react";
+
+const DEFAULT_TIMEOUT_MS = 60 * 60 * 1000; // 1 hour
+
+/**
+ * Monitors user activity and clears the session after a period of inactivity.
+ * Resets the timer on mouse, keyboard, scroll, and touch events.
+ *
+ * Components with long-running operations can pause/resume the timer:
+ *   pauseIdleTimer()  — stops the countdown (e.g. before a long ingest call)
+ *   resumeIdleTimer() — restarts the countdown (e.g. when the call finishes)
+ */
+export function useIdleTimeout(timeoutMs: number = DEFAULT_TIMEOUT_MS) {
+  const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  const handleTimeout = useCallback(() => {
+    const creds = sessionStorage.getItem("creds");
+    if (!creds) return; // Not logged in, nothing to do
+
+    sessionStorage.clear();
+    alert("Session expired due to inactivity. Please log in again.");
+    window.location.href = "/";
+  }, []);
+
+  const resetTimer = useCallback(() => {
+    if (timerRef.current) {
+      clearTimeout(timerRef.current);
+    }
+    // Only set timer if user is logged in
+    if (sessionStorage.getItem("creds")) {
+      timerRef.current = setTimeout(handleTimeout, timeoutMs);
+    }
+  }, [handleTimeout, timeoutMs]);
+
+  const pause = useCallback(() => {
+    if (timerRef.current) {
+      clearTimeout(timerRef.current);
+      timerRef.current = null;
+    }
+  }, []);
+
+  useEffect(() => {
+    const events = ["mousemove", "mousedown", "keydown", "scroll", "touchstart"];
+
+    const onPause = () => pause();
+    const onResume = () => resetTimer();
+
+    events.forEach((event) => window.addEventListener(event, resetTimer));
+    window.addEventListener("idle-timer-pause", onPause);
+    window.addEventListener("idle-timer-resume", onResume);
+    resetTimer(); // Start the timer
+
+    return () => {
+      events.forEach((event) => window.removeEventListener(event, resetTimer));
+      window.removeEventListener("idle-timer-pause", onPause);
+      window.removeEventListener("idle-timer-resume", onResume);
+      if (timerRef.current) {
+        clearTimeout(timerRef.current);
+      }
+    };
+  }, [resetTimer, pause]);
+}
+
+/** Pause the idle timer (e.g. during long-running backend operations). */
+export function pauseIdleTimer() {
+  window.dispatchEvent(new Event("idle-timer-pause"));
+}
+
+/** Resume the idle timer (e.g. when a long-running operation completes). */
+export function resumeIdleTimer() {
+  window.dispatchEvent(new Event("idle-timer-resume"));
+}
diff --git a/graphrag-ui/src/hooks/useRoles.ts b/graphrag-ui/src/hooks/useRoles.ts
new file mode 100644
index 0000000..b9fd578
--- /dev/null
+++ b/graphrag-ui/src/hooks/useRoles.ts
@@ -0,0 +1,122 @@
+import { useState, useEffect, useCallback } from "react";
+
+export interface RolesState {
+  userRoles: string[];
+  graphRoles: Record<string, string[]>;
+  rolesLoaded: boolean;
+  hasCreds: boolean;
+  selectedGraph: string;
+  isSuperuser: boolean;
+  isGlobalDesigner: boolean;
+  isGraphAdmin: boolean;
+  canAccessSetup: boolean;
+}
+
+function parseGraphRoles(raw: unknown): Record<string, string[]> {
+  if (!raw || typeof raw !== "object") return {};
+  return Object.fromEntries(
+    Object.entries(raw as Record<string, unknown>).map(([graph, roles]) => [
+      graph,
+      Array.isArray(roles)
+        ? roles.map((role: string) => role.toLowerCase())
+        : [],
+    ])
+  );
+}
+
+export function useRoles(refreshKey?: unknown): RolesState {
+  const [userRoles, setUserRoles] = useState<string[]>([]);
+  const [graphRoles, setGraphRoles] = useState<Record<string, string[]>>({});
+  const [rolesLoaded, setRolesLoaded] = useState(false);
+  const [hasCreds, setHasCreds] = useState(false);
+  const [selectedGraph, setSelectedGraph] = useState(
+    sessionStorage.getItem("selectedGraph") || ""
+  );
+
+  const loadRoles = useCallback(async () => {
+    const creds = sessionStorage.getItem("creds");
+    if (!creds) {
+      setUserRoles([]);
+      setGraphRoles({});
+      setHasCreds(false);
+      setRolesLoaded(true);
+      return;
+    }
+
+    // Try loading from sessionStorage first (populated at login)
+    const site = JSON.parse(sessionStorage.getItem("site") || "{}");
+    if (Array.isArray(site.roles)) {
+      const roles = site.roles.map((role: string) => role.toLowerCase());
+      setUserRoles(roles);
+      setGraphRoles(parseGraphRoles(site.graph_roles));
+      setSelectedGraph(sessionStorage.getItem("selectedGraph") || "");
+      setHasCreds(true);
+      setRolesLoaded(true);
+      return;
+    }
+
+    // Fallback: fetch from backend (for sessions created before login returned roles)
+    try {
+      const response = await fetch("/ui/roles", {
+        headers: { Authorization: `Basic ${creds}` },
+      });
+      if (!response.ok) {
+        setUserRoles([]);
+        setGraphRoles({});
+        setHasCreds(false);
+        return;
+      }
+      const data = await response.json();
+      const roles = Array.isArray(data.roles) ? data.roles : [];
+      setUserRoles(roles.map((role: string) => role.toLowerCase()));
+      setGraphRoles(parseGraphRoles(data.graph_roles));
+      setSelectedGraph(sessionStorage.getItem("selectedGraph") || "");
+      setHasCreds(true);
+
+      // Persist to site so subsequent reads don't need a fetch
+      site.roles = data.roles;
+      site.graph_roles = data.graph_roles;
+      sessionStorage.setItem("site", JSON.stringify(site));
+    } catch (err) {
+      console.error("Failed to fetch user roles:", err);
+      setUserRoles([]);
+      setGraphRoles({});
+      setHasCreds(false);
+    } finally {
+      setRolesLoaded(true);
+    }
+  }, []);
+
+  useEffect(() => {
+    loadRoles();
+  }, [loadRoles, refreshKey]);
+
+  useEffect(() => {
+    const handleGraphChange = () => {
+      setSelectedGraph(sessionStorage.getItem("selectedGraph") || "");
+    };
+    window.addEventListener("graphrag:selectedGraph", handleGraphChange);
+    return () => {
+      window.removeEventListener("graphrag:selectedGraph", handleGraphChange);
+    };
+  }, []);
+
+  const selectedGraphRoles = graphRoles[selectedGraph] || [];
+  const isSuperuser = userRoles.includes("superuser");
+  const isGlobalDesigner = userRoles.includes("globaldesigner");
+  const isGraphAdmin = selectedGraphRoles.includes("admin");
+  const isAdminOnAnyGraph = (Object.values(graphRoles) as string[][]).some(roles => roles.includes("admin"));
+  const canAccessSetup = isSuperuser || isGlobalDesigner || isAdminOnAnyGraph;
+
+  return {
+    userRoles,
+    graphRoles,
+    rolesLoaded,
+    hasCreds,
+    selectedGraph,
+    isSuperuser,
+    isGlobalDesigner,
+    isGraphAdmin,
+    canAccessSetup,
+  };
+}
diff --git a/graphrag-ui/src/main.tsx b/graphrag-ui/src/main.tsx
index 69cfa82..70a14d3 100755
--- a/graphrag-ui/src/main.tsx
+++ b/graphrag-ui/src/main.tsx
@@ -1,16 +1,32 @@
 import ReactDOM from "react-dom/client";
 import App from "./App.tsx";
 import "./index.css";
-import { Outlet, RouterProvider, createBrowserRouter } from "react-router-dom";
+import { Outlet, RouterProvider, createBrowserRouter, Navigate } from "react-router-dom";
 import Chat from "./pages/Chat";
 import ChatDialog from "./pages/ChatDialog.tsx";
-import Setup from "./pages/Setup.tsx";
+import SetupLayout from "./pages/setup/SetupLayout.tsx";
+import KGAdmin from "./pages/setup/KGAdmin.tsx";
+import IngestGraph from "./pages/setup/IngestGraph.tsx";
+import LLMConfig from "./pages/setup/LLMConfig.tsx";
+import GraphDBConfig from "./pages/setup/GraphDBConfig.tsx";
+import GraphRAGConfig from "./pages/setup/GraphRAGConfig.tsx";
+import CustomizePrompts from "./pages/setup/CustomizePrompts.tsx";
 import { ThemeProvider } from "./components/ThemeProvider.tsx";
 import { ModeToggle } from "@/components/ModeToggle.tsx";
+import { useIdleTimeout } from "./hooks/useIdleTimeout.ts";
 
 import "./components/i18n";
 
+/** Redirect to login if no credentials in session. */
+const RequireAuth = ({ children }: { children: any }) => {
+  if (!sessionStorage.getItem("creds")) {
+    return <Navigate to="/" replace />;
+  }
+  return children;
+};
+
 const Layout = () => {
+  useIdleTimeout();
   return (
     <ThemeProvider defaultTheme="dark" storageKey="vite-ui-theme">
       <ModeToggle />
@@ -30,19 +46,57 @@ const router = createBrowserRouter([
       },
       {
         path: "/chat",
-        element: <Chat />,
+        element: <RequireAuth><Chat /></RequireAuth>,
       },
       {
         path: "/chat-dialog",
-        element: <ChatDialog />,
+        element: <RequireAuth><ChatDialog /></RequireAuth>,
       },
       {
         path: "/preferences",
-        element: <ChatDialog />,
+        element: <RequireAuth><ChatDialog /></RequireAuth>,
       },
       {
         path: "/setup",
-        element: <Setup />,
+        element: <RequireAuth><SetupLayout /></RequireAuth>,
+        children: [
+          {
+            path: "",
+            element: <Navigate to="/setup/kg-admin" replace />,
+          },
+          {
+            path: "kg-admin",
+            element: <KGAdmin />,
+          },
+          {
+            path: "kg-admin/ingest",
+            element: <IngestGraph />,
+          },
+          {
+            path: "server-config",
+            element: <Navigate to="/setup/server-config/llm" replace />,
+          },
+          {
+            path: "server-config/llm",
+            element: <LLMConfig />,
+          },
+          {
+            path: "server-config/graphdb",
+            element: <GraphDBConfig />,
+          },
+          {
+            path: "server-config/graphrag",
+            element: <GraphRAGConfig />,
+          },
+          {
+            path: "prompts",
+            element: <CustomizePrompts />,
+          },
+        ],
+      },
+      {
+        path: "*",
+        element: <Navigate to="/" replace />,
       },
     ],
   },
diff --git a/graphrag-ui/src/pages/Setup.tsx b/graphrag-ui/src/pages/Setup.tsx
index 3ec977d..d5674ac 100644
--- a/graphrag-ui/src/pages/Setup.tsx
+++ b/graphrag-ui/src/pages/Setup.tsx
@@ -102,7 +102,7 @@ const [activeTab, setActiveTab] = useState("upload");
     if (!ingestGraphName) return;
 
     try {
-      const creds = localStorage.getItem("creds");
+      const creds = sessionStorage.getItem("creds");
       const response = await fetch(`/ui/${ingestGraphName}/uploads/list`, {
         headers: { Authorization: `Basic ${creds}` },
       });
@@ -151,7 +151,7 @@ const [activeTab, setActiveTab] = useState("upload");
     setUploadMessage("Uploading files...");
 
     try {
-      const creds = localStorage.getItem("creds");
+      const creds = sessionStorage.getItem("creds");
       const formData = new FormData();
       filesArray.forEach((file) => formData.append("files", file));
 
@@ -200,7 +200,7 @@ const [activeTab, setActiveTab] = useState("upload");
     setUploadMessage("Total size exceeds limit. Uploading files one by one...");
 
     try {
-      const creds = localStorage.getItem("creds");
+      const creds = sessionStorage.getItem("creds");
       let uploadedCount = 0;
       let failedCount = 0;
       const totalFiles = filesArray.length;
@@ -273,7 +273,7 @@ const [activeTab, setActiveTab] = useState("upload");
     console.log("Deleting file:", filename);
 
     try {
-      const creds = localStorage.getItem("creds");
+      const creds = sessionStorage.getItem("creds");
 
       // Delete original file
       const url = `/ui/${ingestGraphName}/uploads?filename=${encodeURIComponent(filename)}`;
@@ -301,7 +301,7 @@ const [activeTab, setActiveTab] = useState("upload");
     if (!shouldDelete) return;
 
     try {
-      const creds = localStorage.getItem("creds");
+      const creds = sessionStorage.getItem("creds");
       const response = await fetch(`/ui/${ingestGraphName}/uploads`, {
         method: "DELETE",
         headers: { Authorization: `Basic ${creds}` },
@@ -323,7 +323,7 @@ const [activeTab, setActiveTab] = useState("upload");
     if (!ingestGraphName) return;
 
     try {
-      const creds = localStorage.getItem("creds");
+      const creds = sessionStorage.getItem("creds");
       const response = await fetch(`/ui/${ingestGraphName}/cloud/list`, {
         headers: { Authorization: `Basic ${creds}` },
       });
@@ -345,7 +345,7 @@ const [activeTab, setActiveTab] = useState("upload");
     setDownloadMessage("Downloading files from cloud storage...");
 
     try {
-      const creds = localStorage.getItem("creds");
+      const creds = sessionStorage.getItem("creds");
       
       // Prepare request body based on provider
       let requestBody: any = { provider: cloudProvider };
@@ -437,7 +437,7 @@ const [activeTab, setActiveTab] = useState("upload");
     if (!ingestGraphName) return;
 
     try {
-      const creds = localStorage.getItem("creds");
+      const creds = sessionStorage.getItem("creds");
       
       // Delete original file
       const url = `/ui/${ingestGraphName}/cloud/delete?filename=${encodeURIComponent(filename)}`;
@@ -462,7 +462,7 @@ const [activeTab, setActiveTab] = useState("upload");
     if (!shouldDelete) return;
 
     try {
-      const creds = localStorage.getItem("creds");
+      const creds = sessionStorage.getItem("creds");
       const response = await fetch(`/ui/${ingestGraphName}/cloud/delete`, {
         method: "DELETE",
         headers: { Authorization: `Basic ${creds}` },
@@ -485,7 +485,7 @@ const [activeTab, setActiveTab] = useState("upload");
     setIsIngesting(true);
     setIngestMessage("Ingesting documents into knowledge graph...");
     try {
-      const creds = localStorage.getItem("creds");
+      const creds = sessionStorage.getItem("creds");
       const folderPath = sourceType === "uploaded" ? `uploads/${ingestGraphName}` : `downloaded_files_cloud/${ingestGraphName}`;
       
       // Use existing ingestJobData if available, otherwise construct from folder path
@@ -547,7 +547,7 @@ const [activeTab, setActiveTab] = useState("upload");
     setIngestMessage("Step 1/2: Creating ingest job...");
 
     try {
-      const creds = localStorage.getItem("creds");
+      const creds = sessionStorage.getItem("creds");
 
       // Step 1: Create ingest job
       const createIngestConfig = {
@@ -643,7 +643,7 @@ const [activeTab, setActiveTab] = useState("upload");
     console.log("fileCount:", fileCount);
 
     try {
-      const creds = localStorage.getItem("creds");
+      const creds = sessionStorage.getItem("creds");
 
       // Call create_ingest to process files
       const createIngestConfig = {
@@ -741,7 +741,7 @@ const [activeTab, setActiveTab] = useState("upload");
     setIsIngesting(true);
 
     try {
-      const creds = localStorage.getItem("creds");
+      const creds = sessionStorage.getItem("creds");
       let loadingInfo: any = {};
 
       if (skipBDAProcessing) {
@@ -815,7 +815,7 @@ const [activeTab, setActiveTab] = useState("upload");
           file_path: outputBucket,
         };
 
-        const filesToIngest = createData.data_source_id.bda_jobs.map((job: any) => job.jobId.split("/")[-1]);
+        const filesToIngest = createData.data_source_id.bda_jobs.map((job: any) => job.jobId.split("/").at(-1));
         setIngestMessage(`Step 2/2: Running document ingest for ${filesToIngest.length} files in ${outputBucket}...`);
       }
 
@@ -859,7 +859,7 @@ const [activeTab, setActiveTab] = useState("upload");
     }
 
     try {
-      const creds = localStorage.getItem("creds");
+      const creds = sessionStorage.getItem("creds");
       const statusResponse = await fetch(`/ui/${graphName}/rebuild_status`, {
         method: "GET",
         headers: {
@@ -930,7 +930,7 @@ const [activeTab, setActiveTab] = useState("upload");
     setRefreshMessage("Verifying rebuild status...");
 
     try {
-      const creds = localStorage.getItem("creds");
+      const creds = sessionStorage.getItem("creds");
 
       // Final status check to prevent race conditions
       const statusCheckResponse = await fetch(`/ui/${refreshGraphName}/rebuild_status`, {
@@ -1000,9 +1000,9 @@ const [activeTab, setActiveTab] = useState("upload");
     }
   }, [refreshOpen, refreshGraphName]);
 
-  // Load available graphs from localStorage on mount
+  // Load available graphs from sessionStorage on mount
   useEffect(() => {
-    const store = JSON.parse(localStorage.getItem("site") || "{}");
+    const store = JSON.parse(sessionStorage.getItem("site") || "{}");
     if (store.graphs && Array.isArray(store.graphs)) {
       setAvailableGraphs(store.graphs);
       // Auto-select first graph if available
@@ -1036,8 +1036,8 @@ const [activeTab, setActiveTab] = useState("upload");
     setStatusType("");
 
     try {
-      // Get credentials from localStorage
-      const creds = localStorage.getItem("creds");
+      // Get credentials from sessionStorage
+      const creds = sessionStorage.getItem("creds");
       if (!creds) {
         throw new Error("Not authenticated. Please login first.");
       }
@@ -1104,10 +1104,10 @@ const [activeTab, setActiveTab] = useState("upload");
       setAvailableGraphs(prev => {
         if (!prev.includes(newGraph)) {
           const updated = [...prev, newGraph];
-          // Update localStorage as well
-          const store = JSON.parse(localStorage.getItem("site") || "{}");
+          // Update sessionStorage as well
+          const store = JSON.parse(sessionStorage.getItem("site") || "{}");
           store.graphs = updated;
-          localStorage.setItem("site", JSON.stringify(store));
+          sessionStorage.setItem("site", JSON.stringify(store));
           return updated;
         }
         return prev;
@@ -1139,7 +1139,7 @@ const [activeTab, setActiveTab] = useState("upload");
             Back to Chat
           </Button>
           <h1 className="text-2xl font-bold mb-2 text-black dark:text-white">
-            Knowledge Graph Administration
+            Knowledge Graph Setup
           </h1>
           <p className="text-sm text-gray-600 dark:text-[#D9D9D9]">
             Configure and manage your knowledge graphs
diff --git a/graphrag-ui/src/pages/setup/CustomizePrompts.tsx b/graphrag-ui/src/pages/setup/CustomizePrompts.tsx
new file mode 100644
index 0000000..d16fe59
--- /dev/null
+++ b/graphrag-ui/src/pages/setup/CustomizePrompts.tsx
@@ -0,0 +1,353 @@
+import React, { useState, useEffect } from "react";
+import { FileText, Save, Loader2 } from "lucide-react";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import ConfigScopeToggle from "@/components/ConfigScopeToggle";
+import { useRoles } from "@/hooks/useRoles";
+import { useLocation } from "react-router-dom";
+
+const ALL_PROMPT_TYPES = [
+  { id: "chatbot_response", name: "Chatbot Responses", description: "Customize how the chatbot responds to user questions" },
+  { id: "entity_relationship", name: "Entity Relationships", description: "Configure entity and relationship extraction from document chunks" },
+  { id: "community_summarization", name: "Community Summarization", description: "Define how community summaries are generated" },
+  { id: "query_generation", name: "Schema Instructions", description: "Configure instructions for schema filtering and schema generation" },
+];
+
+const CustomizePrompts = () => {
+  const location = useLocation();
+  const { isSuperuser, isGlobalDesigner } = useRoles(location.pathname);
+  const graphOnly = !isSuperuser && !isGlobalDesigner;
+  const [configuredProvider, setConfiguredProvider] = useState("");
+  const [isLoading, setIsLoading] = useState(true);
+  const [expandedPrompt, setExpandedPrompt] = useState<string | null>(null);
+  // Only the prompt types returned by the backend (filtered by access level)
+  const [availablePromptIds, setAvailablePromptIds] = useState<string[]>([]);
+  
+  // Prompts loaded from backend (editable content only)
+  const [prompts, setPrompts] = useState({
+    chatbot_response: "",
+    entity_relationship: "",
+    community_summarization: "",
+    query_generation: "",
+  });
+  
+  // Template variables that should not be edited (stored separately)
+  const [promptTemplates, setPromptTemplates] = useState({
+    chatbot_response: "",
+    entity_relationship: "",
+    community_summarization: "",
+    query_generation: "",
+  });
+
+  // Only render prompt types the backend returned for this user
+  const promptTypes = ALL_PROMPT_TYPES.filter(p => availablePromptIds.includes(p.id));
+
+  const [isSaving, setIsSaving] = useState(false);
+  const [saveMessage, setSaveMessage] = useState("");
+  const [saveMessageType, setSaveMessageType] = useState<"success" | "error" | "">("");
+  const [configScope, setConfigScope] = useState<"global" | "graph">("global");
+  const [selectedGraph, setSelectedGraph] = useState(sessionStorage.getItem("selectedGraph") || "");
+  const [availableGraphs, setAvailableGraphs] = useState<string[]>([]);
+
+  const handleSavePrompt = async (promptId: string) => {
+    setIsSaving(true);
+    setSaveMessage("");
+    setSaveMessageType("");
+
+    try {
+      const creds = sessionStorage.getItem("creds");
+      const query = selectedGraph ? `?graphname=${encodeURIComponent(selectedGraph)}` : "";
+      const response = await fetch(`/ui/prompts${query}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Basic ${creds}`,
+        },
+        body: JSON.stringify({
+          prompt_type: promptId,
+          editable_content: prompts[promptId as keyof typeof prompts],
+          template_variables: promptTemplates[promptId as keyof typeof promptTemplates],
+          graphname: selectedGraph || undefined,
+        }),
+      });
+
+      if (!response.ok) {
+        const errorData = await response.json();
+        throw new Error(errorData.detail || "Failed to save prompt");
+      }
+
+      const result = await response.json();
+      setSaveMessage(`✅ ${result.message}`);
+      setSaveMessageType("success");
+      setExpandedPrompt(null); // Collapse after successful save
+    } catch (error: any) {
+      console.error("Error saving prompt:", error);
+      setSaveMessage(`❌ Error: ${error.message}`);
+      setSaveMessageType("error");
+    } finally {
+      setIsSaving(false);
+    }
+  };
+
+  const handlePromptChange = (promptId: string, value: string) => {
+    setPrompts(prev => ({ ...prev, [promptId]: value }));
+  };
+
+  const fetchPrompts = async (graphname?: string) => {
+    setIsLoading(true);
+    const effectiveGraph = graphname ?? selectedGraph;
+    try {
+      const creds = sessionStorage.getItem("creds");
+      const query = effectiveGraph ? `?graphname=${encodeURIComponent(effectiveGraph)}` : "";
+      const response = await fetch(`/ui/prompts${query}`, {
+        headers: { Authorization: `Basic ${creds}` },
+      });
+
+      if (!response.ok) {
+        throw new Error("Failed to fetch prompts");
+      }
+
+      const data = await response.json();
+
+      // Track which prompts this user is allowed to see (backend filters by role)
+      setAvailablePromptIds(Object.keys(data.prompts));
+
+      // Update prompts with fetched data (editable content only)
+      setPrompts({
+        chatbot_response: data.prompts.chatbot_response?.editable_content !== undefined
+          ? data.prompts.chatbot_response.editable_content
+          : (typeof data.prompts.chatbot_response === 'string' ? data.prompts.chatbot_response : ""),
+        entity_relationship: data.prompts.entity_relationship?.editable_content !== undefined
+          ? data.prompts.entity_relationship.editable_content
+          : (typeof data.prompts.entity_relationship === 'string' ? data.prompts.entity_relationship : ""),
+        community_summarization: data.prompts.community_summarization?.editable_content !== undefined
+          ? data.prompts.community_summarization.editable_content
+          : (typeof data.prompts.community_summarization === 'string' ? data.prompts.community_summarization : ""),
+        query_generation: data.prompts.query_generation?.editable_content !== undefined
+          ? data.prompts.query_generation.editable_content
+          : (typeof data.prompts.query_generation === 'string' ? data.prompts.query_generation : ""),
+      });
+
+      // Store template variables separately
+      setPromptTemplates({
+        chatbot_response: data.prompts.chatbot_response?.template_variables || "",
+        entity_relationship: data.prompts.entity_relationship?.template_variables || "",
+        community_summarization: data.prompts.community_summarization?.template_variables || "",
+        query_generation: data.prompts.query_generation?.template_variables || "",
+      });
+
+      // Set configured provider
+      const providerMap: Record<string, string> = {
+        openai: "OpenAI",
+        azure: "Azure OpenAI",
+        genai: "Google GenAI (Gemini)",
+        vertexai: "Google Vertex AI",
+        bedrock: "AWS Bedrock",
+        ollama: "Ollama",
+      };
+      const provider = data.configured_provider?.toLowerCase() || "openai";
+      setConfiguredProvider(providerMap[provider] || data.configured_provider || "OpenAI");
+    } catch (error) {
+      console.error("Error loading prompts:", error);
+      setConfiguredProvider("OpenAI");
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  // Fetch prompts and graph list on mount
+  useEffect(() => {
+    const site = JSON.parse(sessionStorage.getItem("site") || "{}");
+    const graphs = site.graphs || [];
+    setAvailableGraphs(graphs);
+    const storedGraph = sessionStorage.getItem("selectedGraph") || "";
+    if (graphOnly) {
+      // Graph admins must use graph-specific scope
+      setConfigScope("graph");
+      const graph = storedGraph || (graphs.length > 0 ? graphs[0] : "");
+      if (graph) {
+        setSelectedGraph(graph);
+        sessionStorage.setItem("selectedGraph", graph);
+        window.dispatchEvent(new Event("graphrag:selectedGraph"));
+        fetchPrompts(graph);
+      }
+    } else if (storedGraph) {
+      setConfigScope("graph");
+      setSelectedGraph(storedGraph);
+      fetchPrompts(storedGraph);
+    } else {
+      fetchPrompts("");
+    }
+  }, [graphOnly]);
+
+  return (
+    <div className="p-8">
+      <div className="max-w-5xl mx-auto">
+        <div className="mb-8">
+          <div className="flex items-center gap-3 mb-4">
+            <div className="w-12 h-12 rounded-full bg-tigerOrange/10 flex items-center justify-center">
+              <FileText className="h-6 w-6 text-tigerOrange" />
+            </div>
+            <div>
+              <h1 className="text-2xl font-bold text-black dark:text-white">
+                Customize Prompts
+              </h1>
+              <p className="text-sm text-gray-600 dark:text-[#D9D9D9]">
+                Customize the core prompts used by GraphRAG
+              </p>
+            </div>
+          </div>
+        </div>
+
+        {/* Config Scope Toggle */}
+        <ConfigScopeToggle
+          configScope={configScope}
+          selectedGraph={selectedGraph}
+          availableGraphs={availableGraphs}
+          graphOnly={graphOnly}
+          onScopeChange={(scope) => {
+            setConfigScope(scope);
+            setSaveMessage("");
+            setSaveMessageType("");
+            if (scope === "global") {
+              setSelectedGraph("");
+              sessionStorage.removeItem("selectedGraph");
+              window.dispatchEvent(new Event("graphrag:selectedGraph"));
+              fetchPrompts("");
+            } else if (selectedGraph) {
+              fetchPrompts(selectedGraph);
+            }
+          }}
+          onGraphChange={(value) => {
+            setConfigScope("graph");
+            setSelectedGraph(value);
+            sessionStorage.setItem("selectedGraph", value);
+            window.dispatchEvent(new Event("graphrag:selectedGraph"));
+            setSaveMessage("");
+            setSaveMessageType("");
+            fetchPrompts(value);
+          }}
+          graphSelectedHint="Only customized prompts are stored per graph. Others fall back to global defaults."
+        />
+
+        <div className="bg-white dark:bg-shadeA border border-gray-300 dark:border-[#3D3D3D] rounded-lg p-6">
+          <div className="space-y-6">
+            {/* Configured Provider - Read Only */}
+            <div>
+              <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                Configured LLM Provider
+              </label>
+              <div className="relative">
+                <Input
+                  value={isLoading ? "Loading..." : configuredProvider}
+                  disabled
+                  className="dark:border-[#3D3D3D] dark:bg-background opacity-75 cursor-not-allowed"
+                />
+                {isLoading && (
+                  <div className="absolute right-3 top-1/2 -translate-y-1/2">
+                    <Loader2 className="h-4 w-4 animate-spin text-gray-400" />
+                  </div>
+                )}
+              </div>
+              <p className="text-xs text-gray-500 dark:text-gray-400 mt-2">
+                Prompts are configured for your currently active LLM provider. Change provider in Server Configuration.
+              </p>
+            </div>
+
+            {/* Save Message */}
+            {saveMessage && (
+              <div
+                className={`p-4 rounded-lg text-sm ${
+                  saveMessageType === "success"
+                    ? "bg-green-50 dark:bg-green-900/20 text-green-700 dark:text-green-300"
+                    : "bg-red-50 dark:bg-red-900/20 text-red-700 dark:text-red-300"
+                }`}
+              >
+                {saveMessage}
+              </div>
+            )}
+
+            {/* Prompt Templates */}
+            <div className="mt-6 space-y-4">
+              <h3 className="text-lg font-semibold text-black dark:text-white">
+                Prompt Templates
+              </h3>
+              
+              <div className="space-y-4">
+                {promptTypes.map((prompt) => (
+                  <div
+                    key={prompt.id}
+                    className="border border-gray-300 dark:border-[#3D3D3D] rounded-lg p-4"
+                  >
+                    <div className="flex items-start justify-between mb-3">
+                      <div>
+                        <h4 className="font-medium text-black dark:text-white mb-1">
+                          {prompt.name}
+                        </h4>
+                        <p className="text-sm text-gray-600 dark:text-gray-400">
+                          {prompt.description}
+                        </p>
+                      </div>
+                      <Button
+                        onClick={() => setExpandedPrompt(expandedPrompt === prompt.id ? null : prompt.id)}
+                        variant="outline"
+                        size="sm"
+                        className="dark:border-[#3D3D3D]"
+                      >
+                        {expandedPrompt === prompt.id ? "Collapse" : "Edit"}
+                      </Button>
+                    </div>
+                    
+                    {expandedPrompt === prompt.id && (
+                      <div className="mt-4 space-y-3">
+                        <textarea
+                          value={prompts[prompt.id as keyof typeof prompts]}
+                          onChange={(e) => handlePromptChange(prompt.id, e.target.value)}
+                          rows={15}
+                          className="w-full p-3 rounded border dark:border-[#3D3D3D] dark:bg-background text-sm font-mono"
+                          placeholder="Enter your prompt template here..."
+                        />
+                        <div className="flex gap-2">
+                          <Button
+                            onClick={() => handleSavePrompt(prompt.id)}
+                            disabled={isSaving}
+                            className="gradient text-white"
+                            size="sm"
+                          >
+                            {isSaving ? (
+                              <>
+                                <Loader2 className="h-4 w-4 mr-2 animate-spin" />
+                                Saving...
+                              </>
+                            ) : (
+                              <>
+                                <Save className="h-4 w-4 mr-2" />
+                                Save Prompt
+                              </>
+                            )}
+                          </Button>
+                          <Button
+                            onClick={() => setExpandedPrompt(null)}
+                            variant="outline"
+                            size="sm"
+                            className="dark:border-[#3D3D3D]"
+                          >
+                            Cancel
+                          </Button>
+                        </div>
+                      </div>
+                    )}
+                  </div>
+                ))}
+              </div>
+            </div>
+
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+};
+
+export default CustomizePrompts;
+
diff --git a/graphrag-ui/src/pages/setup/GraphDBConfig.tsx b/graphrag-ui/src/pages/setup/GraphDBConfig.tsx
new file mode 100644
index 0000000..1d478cd
--- /dev/null
+++ b/graphrag-ui/src/pages/setup/GraphDBConfig.tsx
@@ -0,0 +1,508 @@
+import React, { useState, useEffect } from "react";
+import { Server, Save, CheckCircle2 } from "lucide-react";
+import { Input } from "@/components/ui/input";
+import { Button } from "@/components/ui/button";
+
+const GraphDBConfig = () => {
+  // Default values for fields — shown as placeholders, used if user leaves field empty
+  const DEFAULTS = {
+    hostname: "http://tigergraph",
+    restppPort: "9000",
+    gsPort: "14240",
+    username: "tigergraph",
+    defaultTimeout: "300",
+    defaultMemThreshold: "5000",
+    defaultThreadLimit: "8",
+  };
+
+  const [hostname, setHostname] = useState("");
+  const [restppPort, setRestppPort] = useState("");
+  const [gsPort, setGsPort] = useState("");
+  const [username, setUsername] = useState("");
+  const [password, setPassword] = useState("");
+  const [getToken, setGetToken] = useState(false);
+  const [useApiToken, setUseApiToken] = useState(false);
+  const [apiToken, setApiToken] = useState("");
+  const [defaultTimeout, setDefaultTimeout] = useState("");
+  const [defaultMemThreshold, setDefaultMemThreshold] = useState("");
+  const [defaultThreadLimit, setDefaultThreadLimit] = useState("");
+
+  /** Return the effective value: user input if non-empty, otherwise the default */
+  const effective = (value: string, key: keyof typeof DEFAULTS) => value || DEFAULTS[key];
+  
+  // Track original values to detect changes
+  const [originalHostname, setOriginalHostname] = useState("");
+  const [originalUsername, setOriginalUsername] = useState("");
+  
+  const [isLoading, setIsLoading] = useState(false);
+  const [isTesting, setIsTesting] = useState(false);
+  const [isSaving, setIsSaving] = useState(false);
+  const [connectionTested, setConnectionTested] = useState(false);
+  const [message, setMessage] = useState("");
+  const [messageType, setMessageType] = useState<"success" | "error" | "">("");
+
+  useEffect(() => {
+    fetchConfig();
+  }, []);
+
+
+  const fetchConfig = async () => {
+    setIsLoading(true);
+    try {
+      const creds = sessionStorage.getItem("creds");
+      const response = await fetch("/ui/config", {
+        headers: { Authorization: `Basic ${creds}` },
+      });
+
+      if (!response.ok) {
+        throw new Error("Failed to fetch configuration");
+      }
+
+      const data = await response.json();
+      const dbConfig = data.db_config;
+
+      if (dbConfig) {
+        // Only populate state with non-default values; defaults show as placeholders
+        const h = dbConfig.hostname || "";
+        const u = dbConfig.username || "";
+        setHostname(h === DEFAULTS.hostname ? "" : h);
+        setOriginalHostname(h || DEFAULTS.hostname);
+        setRestppPort(dbConfig.restppPort === DEFAULTS.restppPort ? "" : (dbConfig.restppPort || ""));
+        setGsPort(dbConfig.gsPort === DEFAULTS.gsPort ? "" : (dbConfig.gsPort || ""));
+        setUsername(u === DEFAULTS.username ? "" : u);
+        setOriginalUsername(u || DEFAULTS.username);
+        setPassword(dbConfig.password || "");
+        setGetToken(dbConfig.getToken || false);
+        const token = dbConfig.apiToken || "";
+        setApiToken(token);
+        setUseApiToken(!!token);
+        const t = String(dbConfig.default_timeout || "");
+        const m = String(dbConfig.default_mem_threshold || "");
+        const tl = String(dbConfig.default_thread_limit || "");
+        setDefaultTimeout(t === DEFAULTS.defaultTimeout ? "" : t);
+        setDefaultMemThreshold(m === DEFAULTS.defaultMemThreshold ? "" : m);
+        setDefaultThreadLimit(tl === DEFAULTS.defaultThreadLimit ? "" : tl);
+      }
+    } catch (error: any) {
+      console.error("Error fetching config:", error);
+      setMessage(`Failed to load configuration: ${error.message}`);
+      setMessageType("error");
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  const handleTestConnection = async () => {
+    setIsTesting(true);
+    setMessage("");
+    setMessageType("");
+    setConnectionTested(false);
+
+    try {
+      const creds = sessionStorage.getItem("creds");
+      const testConfig: any = {
+        hostname: effective(hostname, "hostname"),
+        restppPort: effective(restppPort, "restppPort"),
+        gsPort: effective(gsPort, "gsPort"),
+        username: effective(username, "username"),
+        password,
+        getToken,
+      };
+      if (useApiToken && apiToken.trim()) {
+        testConfig.apiToken = apiToken.trim();
+      }
+
+      const response = await fetch("/ui/config/db/test", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Basic ${creds}`,
+        },
+        body: JSON.stringify(testConfig),
+      });
+
+      const result = await response.json();
+
+      if (response.ok && result.status === "success") {
+        setConnectionTested(true);
+        setMessage("Connection successful! You can now save the configuration.");
+        setMessageType("success");
+      } else {
+        setMessage(result.message || "Connection test failed");
+        setMessageType("error");
+      }
+    } catch (error: any) {
+      setMessage(`Connection test error: ${error.message}`);
+      setMessageType("error");
+    } finally {
+      setIsTesting(false);
+    }
+  };
+
+  const handleSave = async () => {
+    if (!connectionTested) {
+      setMessage("Please test the connection first before saving");
+      setMessageType("error");
+      return;
+    }
+    setIsSaving(true);
+    setMessage("");
+    setMessageType("");
+
+    try {
+      const creds = sessionStorage.getItem("creds");
+      const effectiveHostname = effective(hostname, "hostname");
+      const effectiveUsername = effective(username, "username");
+      const dbConfigData: any = {
+        hostname: effectiveHostname,
+        restppPort: effective(restppPort, "restppPort"),
+        gsPort: effective(gsPort, "gsPort"),
+        username: effectiveUsername,
+        password,
+        getToken,
+        default_timeout: parseInt(effective(defaultTimeout, "defaultTimeout")),
+        default_mem_threshold: parseInt(effective(defaultMemThreshold, "defaultMemThreshold")),
+        default_thread_limit: parseInt(effective(defaultThreadLimit, "defaultThreadLimit")),
+      };
+      if (useApiToken && apiToken.trim()) {
+        dbConfigData.apiToken = apiToken.trim();
+      }
+
+      const response = await fetch("/ui/config/db", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Basic ${creds}`,
+        },
+        body: JSON.stringify(dbConfigData),
+      });
+
+      const result = await response.json();
+
+      if (response.ok) {
+        setMessage("GraphDB configuration saved successfully!");
+        setMessageType("success");
+        setConnectionTested(false); // Reset after save
+        
+        // Check if hostname or username changed from what was loaded
+        const hostnameChanged = originalHostname && effectiveHostname !== originalHostname;
+        const usernameChanged = originalUsername && effectiveUsername !== originalUsername;
+        
+        // If hostname OR username changed, redirect to login so services reconnect
+        if (hostnameChanged || usernameChanged) {
+          const reason = hostnameChanged 
+            ? "GraphDB hostname changed. Please relogin with the new credentials to connect to the new instance."
+            : "GraphDB username changed. Please relogin with the new credentials.";
+          
+          setTimeout(() => {
+            // Clear sessionStorage and redirect to login
+            sessionStorage.removeItem("creds");
+            alert(reason);
+            window.location.href = "/"; // Redirect to root (login page)
+          }, 2000); // Give user 2 seconds to see the success message
+        } else {
+          // Update originals after successful save (only if no redirect)
+          setOriginalHostname(effectiveHostname);
+          setOriginalUsername(effectiveUsername);
+        }
+      } else {
+        setMessage(result.detail || "Failed to save configuration");
+        setMessageType("error");
+      }
+    } catch (error: any) {
+      setMessage(`Save error: ${error.message}`);
+      setMessageType("error");
+    } finally {
+      setIsSaving(false);
+    }
+  };
+
+  return (
+    <div className="p-8">
+      <div className="max-w-5xl mx-auto">
+        <div className="mb-8">
+          <div className="flex items-center gap-3 mb-4">
+            <div className="w-12 h-12 rounded-full bg-tigerOrange/10 flex items-center justify-center">
+              <Server className="h-6 w-6 text-tigerOrange" />
+            </div>
+            <div>
+              <h1 className="text-2xl font-bold text-black dark:text-white">
+                Graph Database Configuration
+              </h1>
+              <p className="text-sm text-gray-600 dark:text-[#D9D9D9]">
+                Configure your TigerGraph database connection and settings
+              </p>
+            </div>
+          </div>
+        </div>
+
+        <div className="bg-white dark:bg-shadeA border border-gray-300 dark:border-[#3D3D3D] rounded-lg p-6">
+          <fieldset>
+            <div className="space-y-6">
+            <div>
+              <h2 className="text-lg font-semibold mb-4 text-black dark:text-white">
+                Database Connection
+              </h2>
+              <p className="text-sm text-gray-600 dark:text-[#D9D9D9] mb-6">
+                Configure your TigerGraph database connection parameters.
+              </p>
+
+              <div className="space-y-4">
+                <div>
+                  <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                    Hostname
+                  </label>
+                  <Input
+                    type="text"
+                    className="dark:border-[#3D3D3D] dark:bg-background"
+                    placeholder="http://tigergraph"
+                    value={hostname}
+                    onChange={(e) => {
+                      setHostname(e.target.value);
+                      setConnectionTested(false);
+                      setMessage("");
+                      setMessageType("");
+                    }}
+                  />
+                  <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                    TigerGraph server hostname
+                  </p>
+                </div>
+
+                <div className="grid grid-cols-2 gap-4">
+                  <div>
+                    <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                      RESTPP Port
+                    </label>
+                    <Input
+                      type="text"
+                      className="dark:border-[#3D3D3D] dark:bg-background"
+                      placeholder="9000"
+                      value={restppPort}
+                      onChange={(e) => {
+                        setRestppPort(e.target.value);
+                        setConnectionTested(false);
+                        setMessage("");
+                        setMessageType("");
+                      }}
+                    />
+                  </div>
+
+                  <div>
+                    <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                      GS Port
+                    </label>
+                    <Input
+                      type="text"
+                      className="dark:border-[#3D3D3D] dark:bg-background"
+                      placeholder="14240"
+                      value={gsPort}
+                      onChange={(e) => {
+                        setGsPort(e.target.value);
+                        setConnectionTested(false);
+                        setMessage("");
+                        setMessageType("");
+                      }}
+                    />
+                  </div>
+                </div>
+
+                <div className="flex items-center space-x-2">
+                  <input
+                    type="checkbox"
+                    id="useApiToken"
+                    className="rounded border-gray-300 dark:border-[#3D3D3D]"
+                    checked={useApiToken}
+                    onChange={(e) => {
+                      setUseApiToken(e.target.checked);
+                      if (!e.target.checked) setApiToken("");
+                      setConnectionTested(false);
+                      setMessage("");
+                      setMessageType("");
+                    }}
+                  />
+                  <label htmlFor="useApiToken" className="text-sm font-medium text-black dark:text-white">
+                    Use pre-generated API Token
+                  </label>
+                </div>
+
+                {useApiToken ? (
+                  <div>
+                    <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                      API Token
+                    </label>
+                    <Input
+                      type="password"
+                      className="dark:border-[#3D3D3D] dark:bg-background"
+                      placeholder="Enter API token"
+                      value={apiToken}
+                      onChange={(e) => {
+                        setApiToken(e.target.value);
+                        setConnectionTested(false);
+                        setMessage("");
+                        setMessageType("");
+                      }}
+                    />
+                    <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                      Token-based auth is used instead of username/password for API requests
+                    </p>
+                  </div>
+                ) : (
+                  <>
+                    <div className="grid grid-cols-2 gap-4">
+                      <div>
+                        <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                          Username
+                        </label>
+                        <Input
+                          type="text"
+                          className="dark:border-[#3D3D3D] dark:bg-background"
+                          placeholder={DEFAULTS.username}
+                          value={username}
+                          onChange={(e) => {
+                            setUsername(e.target.value);
+                            setConnectionTested(false);
+                            setMessage("");
+                            setMessageType("");
+                          }}
+                        />
+                      </div>
+
+                      <div>
+                        <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                          Password
+                        </label>
+                        <Input
+                          type="password"
+                          className="dark:border-[#3D3D3D] dark:bg-background"
+                          placeholder="Enter password"
+                          value={password}
+                          onChange={(e) => {
+                            setPassword(e.target.value);
+                            setConnectionTested(false);
+                            setMessage("");
+                            setMessageType("");
+                          }}
+                        />
+                      </div>
+                    </div>
+
+                    <div className="flex items-center space-x-2">
+                      <input
+                        type="checkbox"
+                        id="getToken"
+                        className="rounded border-gray-300 dark:border-[#3D3D3D]"
+                        checked={getToken}
+                        onChange={(e) => {
+                          setGetToken(e.target.checked);
+                          setConnectionTested(false);
+                          setMessage("");
+                          setMessageType("");
+                        }}
+                      />
+                      <label htmlFor="getToken" className="text-sm font-medium text-black dark:text-white">
+                        Get Token
+                      </label>
+                    </div>
+                  </>
+                )}
+
+                <div className="grid grid-cols-3 gap-4">
+                  <div>
+                    <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                      Default Timeout
+                    </label>
+                    <Input
+                      type="number"
+                      className="dark:border-[#3D3D3D] dark:bg-background"
+                      placeholder="300"
+                      value={defaultTimeout}
+                      onChange={(e) => setDefaultTimeout(e.target.value)}
+                    />
+                    <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                      Seconds
+                    </p>
+                  </div>
+
+                  <div>
+                    <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                      Memory Threshold
+                    </label>
+                    <Input
+                      type="number"
+                      className="dark:border-[#3D3D3D] dark:bg-background"
+                      placeholder="5000"
+                      value={defaultMemThreshold}
+                      onChange={(e) => setDefaultMemThreshold(e.target.value)}
+                    />
+                    <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                      MB
+                    </p>
+                  </div>
+
+                  <div>
+                    <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                      Thread Limit
+                    </label>
+                    <Input
+                      type="number"
+                      className="dark:border-[#3D3D3D] dark:bg-background"
+                      placeholder="8"
+                      value={defaultThreadLimit}
+                      onChange={(e) => setDefaultThreadLimit(e.target.value)}
+                    />
+                    <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                      Threads
+                    </p>
+                  </div>
+                </div>
+
+                {message && (
+                  <div
+                    className={`p-4 rounded-lg ${
+                      messageType === "success"
+                        ? "bg-green-50 dark:bg-green-900/20 text-green-800 dark:text-green-200"
+                        : "bg-red-50 dark:bg-red-900/20 text-red-800 dark:text-red-200"
+                    }`}
+                  >
+                    {message}
+                  </div>
+                )}
+
+                <div className="flex items-center gap-4">
+                  <Button
+                    onClick={handleTestConnection}
+                    disabled={isTesting || (!password.trim() && !(useApiToken && apiToken.trim()))}
+                    className="bg-blue-600 hover:bg-blue-700 text-white"
+                  >
+                    <CheckCircle2 className="h-4 w-4 mr-2" />
+                    {isTesting ? "Testing..." : "Test Connection"}
+                  </Button>
+
+                  <Button
+                    onClick={handleSave}
+                    disabled={!connectionTested || isSaving}
+                    className="gradient text-white"
+                  >
+                    <Save className="h-4 w-4 mr-2" />
+                    {isSaving ? "Saving..." : "Save Configuration"}
+                  </Button>
+
+                  {!password.trim() && !(useApiToken && apiToken.trim()) && (
+                    <p className="text-xs text-gray-500 dark:text-gray-400">
+                      Enter password or API token to test connection
+                    </p>
+                  )}
+                </div>
+              </div>
+            </div>
+            </div>
+          </fieldset>
+        </div>
+      </div>
+    </div>
+  );
+};
+
+export default GraphDBConfig;
+
diff --git a/graphrag-ui/src/pages/setup/GraphRAGConfig.tsx b/graphrag-ui/src/pages/setup/GraphRAGConfig.tsx
new file mode 100644
index 0000000..0e05e4e
--- /dev/null
+++ b/graphrag-ui/src/pages/setup/GraphRAGConfig.tsx
@@ -0,0 +1,680 @@
+import React, { useState, useEffect } from "react";
+import { Settings, Save, Loader2 } from "lucide-react";
+import { Input } from "@/components/ui/input";
+import { Button } from "@/components/ui/button";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import ConfigScopeToggle from "@/components/ConfigScopeToggle";
+
+const GraphRAGConfig = () => {
+  const [selectedGraph, setSelectedGraph] = useState(sessionStorage.getItem("selectedGraph") || "");
+  const [availableGraphs, setAvailableGraphs] = useState<string[]>([]);
+  const [reuseEmbedding, setReuseEmbedding] = useState(false);
+  const [eccUrl, setEccUrl] = useState("http://graphrag-ecc:8001");
+  const [chatHistoryUrl, setChatHistoryUrl] = useState("http://chat-history:8002");
+
+  // Default chunker (used when no chunker specified in document)
+  const [defaultChunker, setDefaultChunker] = useState("semantic");
+
+  // Retrieval settings
+  const [topK, setTopK] = useState("5");
+  const [numHops, setNumHops] = useState("2");
+  const [numSeenMin, setNumSeenMin] = useState("2");
+  const [communityLevel, setCommunityLevel] = useState("2");
+  const [docOnly, setDocOnly] = useState(false);
+
+  // Advanced ingestion settings
+  const [showAdvanced, setShowAdvanced] = useState(false);
+  const [loadBatchSize, setLoadBatchSize] = useState("500");
+  const [upsertDelay, setUpsertDelay] = useState("0");
+  const [maxConcurrency, setMaxConcurrency] = useState("10");
+
+  // Chunker-specific settings
+  const [chunkSize, setChunkSize] = useState("1024");
+  const [overlapSize, setOverlapSize] = useState("0");
+  const [semanticMethod, setSemanticMethod] = useState("percentile");
+  const [semanticThreshold, setSemanticThreshold] = useState("0.95");
+  const [regexPattern, setRegexPattern] = useState("\\r?\\n");
+
+  const [isLoading, setIsLoading] = useState(false);
+  const [isSaving, setIsSaving] = useState(false);
+  const [message, setMessage] = useState("");
+  const [messageType, setMessageType] = useState<"success" | "error" | "">("");
+
+  // Scope: "global" edits global config, "graph" edits per-graph overrides
+  const [configScope, setConfigScope] = useState<"global" | "graph">("global");
+  const [graphOverrides, setGraphOverrides] = useState<Record<string, any>>({});
+
+  useEffect(() => {
+    const site = JSON.parse(sessionStorage.getItem("site") || "{}");
+    setAvailableGraphs(site.graphs || []);
+    fetchConfig();
+  }, []);
+
+
+  const applyGraphragConfig = (graphragConfig: any) => {
+    if (!graphragConfig) return;
+    setReuseEmbedding(graphragConfig.reuse_embedding || false);
+    setEccUrl(graphragConfig.ecc || "http://graphrag-ecc:8001");
+    setChatHistoryUrl(graphragConfig.chat_history_api || "http://chat-history:8002");
+    setDefaultChunker(graphragConfig.chunker || "semantic");
+    setTopK(String(graphragConfig.top_k ?? 5));
+    setNumHops(String(graphragConfig.num_hops ?? 2));
+    setNumSeenMin(String(graphragConfig.num_seen_min ?? 2));
+    setCommunityLevel(String(graphragConfig.community_level ?? 2));
+    setDocOnly(graphragConfig.doc_only || false);
+    setLoadBatchSize(String(graphragConfig.load_batch_size ?? 500));
+    setUpsertDelay(String(graphragConfig.upsert_delay ?? 0));
+    setMaxConcurrency(String(graphragConfig.default_concurrency ?? 10));
+
+    const chunkerConfig = graphragConfig.chunker_config || {};
+    setChunkSize(String(chunkerConfig.chunk_size || 1024));
+    setOverlapSize(String(chunkerConfig.overlap_size || 0));
+    setSemanticMethod(chunkerConfig.method || "percentile");
+    setSemanticThreshold(String(chunkerConfig.threshold || 0.95));
+    setRegexPattern(chunkerConfig.pattern || "\\r?\\n");
+  };
+
+  const fetchConfig = async (scope?: "global" | "graph", graphname?: string) => {
+    setIsLoading(true);
+    const effectiveScope = scope ?? configScope;
+    const effectiveGraph = graphname ?? selectedGraph;
+    try {
+      const creds = sessionStorage.getItem("creds");
+      const params = new URLSearchParams();
+      if (effectiveGraph) params.set("graphname", effectiveGraph);
+      if (effectiveScope === "graph") params.set("scope", "graph");
+      const queryString = params.toString() ? `?${params.toString()}` : "";
+      const response = await fetch(`/ui/config${queryString}`, {
+        headers: { Authorization: `Basic ${creds}` },
+      });
+
+      if (!response.ok) {
+        throw new Error("Failed to fetch configuration");
+      }
+
+      const data = await response.json();
+
+      if (effectiveScope === "graph" && data.graphrag_overrides) {
+        setGraphOverrides(data.graphrag_overrides);
+        // Show per-graph values: merge global + overrides for display
+        const merged = { ...data.graphrag_config, ...data.graphrag_overrides };
+        applyGraphragConfig(merged);
+      } else {
+        setGraphOverrides({});
+        applyGraphragConfig(data.graphrag_config);
+      }
+    } catch (error: any) {
+      console.error("Error fetching config:", error);
+      setMessage(`Failed to load configuration: ${error.message}`);
+      setMessageType("error");
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  const handleSave = async () => {
+    setIsSaving(true);
+    setMessage("");
+    setMessageType("");
+
+    try {
+      const creds = sessionStorage.getItem("creds");
+      
+      // Prepare chunker config based on selected chunker type
+      const chunkerConfig: any = {};
+      
+      if (defaultChunker === "character" || defaultChunker === "markdown" || defaultChunker === "recursive") {
+        chunkerConfig.chunk_size = parseInt(chunkSize);
+        chunkerConfig.overlap_size = parseInt(overlapSize);
+      } else if (defaultChunker === "semantic") {
+        chunkerConfig.method = semanticMethod;
+        chunkerConfig.threshold = parseFloat(semanticThreshold);
+      } else if (defaultChunker === "regex") {
+        chunkerConfig.pattern = regexPattern;
+      } else if (defaultChunker === "html") {
+        // HTML chunker doesn't require specific config in the current implementation
+        // but we keep it consistent
+      }
+      
+      const graphragConfigData: any = {
+        reuse_embedding: reuseEmbedding,
+        ecc: eccUrl,
+        chat_history_api: chatHistoryUrl,
+        chunker: defaultChunker,
+        chunker_config: chunkerConfig,
+        top_k: parseInt(topK),
+        num_hops: parseInt(numHops),
+        num_seen_min: parseInt(numSeenMin),
+        community_level: parseInt(communityLevel),
+        doc_only: docOnly,
+        load_batch_size: parseInt(loadBatchSize),
+        upsert_delay: parseInt(upsertDelay),
+        default_concurrency: parseInt(maxConcurrency),
+      };
+
+      if (configScope === "graph") {
+        graphragConfigData.scope = "graph";
+        graphragConfigData.graphname = selectedGraph;
+      }
+
+      const response = await fetch("/ui/config/graphrag", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Basic ${creds}`,
+        },
+        body: JSON.stringify(graphragConfigData),
+      });
+
+      if (!response.ok) {
+        const errorData = await response.json();
+        throw new Error(errorData.detail || "Failed to save GraphRAG configuration");
+      }
+
+      const result = await response.json();
+      setMessage(result.message || "GraphRAG configuration saved successfully!");
+      setMessageType("success");
+      
+      // Auto-hide success message after 3 seconds
+      setTimeout(() => {
+        setMessage("");
+        setMessageType("");
+      }, 3000);
+    } catch (error: any) {
+      console.error("Error saving GraphRAG config:", error);
+      setMessage(`❌ Error: ${error.message}`);
+      setMessageType("error");
+    } finally {
+      setIsSaving(false);
+    }
+  };
+
+  return (
+    <div className="p-8">
+      <div className="max-w-5xl mx-auto">
+        <div className="mb-8">
+          <div className="flex items-center gap-3 mb-4">
+            <div className="w-12 h-12 rounded-full bg-tigerOrange/10 flex items-center justify-center">
+              <Settings className="h-6 w-6 text-tigerOrange" />
+            </div>
+            <div>
+              <h1 className="text-2xl font-bold text-black dark:text-white">
+                GraphRAG Configuration
+              </h1>
+              <p className="text-sm text-gray-600 dark:text-[#D9D9D9]">
+                Configure GraphRAG-specific parameters and processing settings
+              </p>
+            </div>
+          </div>
+        </div>
+
+        {/* Config Scope Toggle */}
+        <ConfigScopeToggle
+          configScope={configScope}
+          selectedGraph={selectedGraph}
+          availableGraphs={availableGraphs}
+          onScopeChange={(scope) => {
+            setConfigScope(scope);
+            if (scope === "global") {
+              fetchConfig("global");
+            } else if (selectedGraph) {
+              fetchConfig("graph", selectedGraph);
+            }
+          }}
+          onGraphChange={(value) => {
+            setConfigScope("graph");
+            setSelectedGraph(value);
+            sessionStorage.setItem("selectedGraph", value);
+            window.dispatchEvent(new Event("graphrag:selectedGraph"));
+            fetchConfig("graph", value);
+          }}
+          graphSelectedHint={
+            Object.keys(graphOverrides).length > 0
+              ? `Overridden keys: ${Object.keys(graphOverrides).join(", ")}. Other settings are inherited from global.`
+              : "No per-graph overrides set. All settings are inherited from global defaults."
+          }
+        />
+
+        {/* Success/Error Message */}
+        {message && (
+          <div
+            className={`p-4 rounded-lg mb-6 ${
+              messageType === "success"
+                ? "bg-green-50 dark:bg-green-900/20 text-green-700 dark:text-green-300 border border-green-200 dark:border-green-800"
+                : "bg-red-50 dark:bg-red-900/20 text-red-700 dark:text-red-300 border border-red-200 dark:border-red-800"
+            }`}
+          >
+            {message}
+          </div>
+        )}
+
+        <fieldset>
+        <div className="space-y-6">
+          {/* General Settings */}
+          <div className="bg-white dark:bg-shadeA border border-gray-300 dark:border-[#3D3D3D] rounded-lg p-6">
+            <h2 className="text-lg font-semibold mb-4 text-black dark:text-white">
+              General Settings
+            </h2>
+            <p className="text-sm text-gray-600 dark:text-[#D9D9D9] mb-6">
+              Configure general GraphRAG parameters.
+            </p>
+
+            <div className="space-y-4">
+              <div>
+                <div className="flex items-center space-x-2">
+                  <input
+                    type="checkbox"
+                    id="reuseEmbedding"
+                    className="rounded border-gray-300 dark:border-[#3D3D3D]"
+                    checked={reuseEmbedding}
+                    onChange={(e) => setReuseEmbedding(e.target.checked)}
+                  />
+                  <label htmlFor="reuseEmbedding" className="text-sm font-medium text-black dark:text-white">
+                    Reuse Embedding
+                  </label>
+                </div>
+                <p className="text-xs text-gray-600 dark:text-[#D9D9D9] mt-1 ml-6">
+                  Skip fetching new embedding if embedding is already attached to it
+                </p>
+              </div>
+
+              <div className="grid grid-cols-2 gap-4">
+                <div>
+                  <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                    Top K
+                  </label>
+                  <Input
+                    type="number"
+                    min="1"
+                    className="dark:border-[#3D3D3D] dark:bg-background"
+                    placeholder="5"
+                    value={topK}
+                    onChange={(e) => setTopK(e.target.value)}
+                  />
+                  <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                    Number of top similar results to retrieve during search
+                  </p>
+                </div>
+
+                <div>
+                  <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                    Number of Hops
+                  </label>
+                  <Input
+                    type="number"
+                    min="1"
+                    className="dark:border-[#3D3D3D] dark:bg-background"
+                    placeholder="2"
+                    value={numHops}
+                    onChange={(e) => setNumHops(e.target.value)}
+                  />
+                  <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                    Number of graph hops to traverse when expanding retrieved results
+                  </p>
+                </div>
+              </div>
+
+              <div className="grid grid-cols-2 gap-4">
+                <div>
+                  <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                    Min Seen Count
+                  </label>
+                  <Input
+                    type="number"
+                    min="1"
+                    className="dark:border-[#3D3D3D] dark:bg-background"
+                    placeholder="2"
+                    value={numSeenMin}
+                    onChange={(e) => setNumSeenMin(e.target.value)}
+                  />
+                  <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                    Minimum times a node must appear across retrievals to be included in results
+                  </p>
+                </div>
+
+                <div>
+                  <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                    Community Level
+                  </label>
+                  <Input
+                    type="number"
+                    min="1"
+                    className="dark:border-[#3D3D3D] dark:bg-background"
+                    placeholder="2"
+                    value={communityLevel}
+                    onChange={(e) => setCommunityLevel(e.target.value)}
+                  />
+                  <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                    Community hierarchy level used for community search
+                  </p>
+                </div>
+              </div>
+
+              <div>
+                <div className="flex items-center space-x-2">
+                  <input
+                    type="checkbox"
+                    id="docOnly"
+                    className="rounded border-gray-300 dark:border-[#3D3D3D]"
+                    checked={docOnly}
+                    onChange={(e) => setDocOnly(e.target.checked)}
+                  />
+                  <label htmlFor="docOnly" className="text-sm font-medium text-black dark:text-white">
+                    Document Only Search
+                  </label>
+                </div>
+                <p className="text-xs text-gray-600 dark:text-[#D9D9D9] mt-1 ml-6">
+                  Retrieve original documents instead of document chunks in results
+                </p>
+              </div>
+            </div>
+          </div>
+
+          {/* Chunker Settings */}
+          <div className="bg-white dark:bg-shadeA border border-gray-300 dark:border-[#3D3D3D] rounded-lg p-6">
+            <h2 className="text-lg font-semibold mb-4 text-black dark:text-white">
+              Chunker Settings
+            </h2>
+            <p className="text-sm text-gray-600 dark:text-[#D9D9D9] mb-6">
+              Configure document chunking for ingestion
+            </p>
+
+            <div className="space-y-4">
+              <div>
+                <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                  Default Chunker
+                </label>
+                <Select value={defaultChunker} onValueChange={setDefaultChunker}>
+                  <SelectTrigger className="dark:border-[#3D3D3D] dark:bg-background">
+                    <SelectValue placeholder="Select default chunker" />
+                  </SelectTrigger>
+                  <SelectContent>
+                    <SelectItem value="semantic">Semantic Chunker</SelectItem>
+                    <SelectItem value="character">Character Chunker</SelectItem>
+                    <SelectItem value="regex">Regex Chunker</SelectItem>
+                    <SelectItem value="markdown">Markdown Chunker</SelectItem>
+                    <SelectItem value="html">HTML Chunker</SelectItem>
+                    <SelectItem value="recursive">Recursive Chunker</SelectItem>
+                  </SelectContent>
+                </Select>
+                <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                  Used when no chunker is specified for a document
+                </p>
+              </div>
+
+              {/* Settings for character/markdown/recursive chunkers */}
+              {(defaultChunker === "character" || defaultChunker === "markdown" || defaultChunker === "recursive") && (
+                <div className="grid grid-cols-2 gap-4">
+                  <div>
+                    <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                      Chunk Size
+                    </label>
+                    <Input
+                      type="number"
+                      className="dark:border-[#3D3D3D] dark:bg-background"
+                      placeholder="1024"
+                      value={chunkSize}
+                      onChange={(e) => setChunkSize(e.target.value)}
+                    />
+                    <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                      Maximum size of each chunk
+                    </p>
+                  </div>
+
+                  <div>
+                    <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                      Overlap Size
+                    </label>
+                    <Input
+                      type="number"
+                      className="dark:border-[#3D3D3D] dark:bg-background"
+                      placeholder="0"
+                      value={overlapSize}
+                      onChange={(e) => setOverlapSize(e.target.value)}
+                    />
+                    <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                      Overlap between consecutive chunks
+                    </p>
+                  </div>
+                </div>
+              )}
+
+              {/* Settings for semantic chunker */}
+              {defaultChunker === "semantic" && (
+                <div className="grid grid-cols-2 gap-4">
+                  <div>
+                    <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                      Semantic Method
+                    </label>
+                    <Select value={semanticMethod} onValueChange={setSemanticMethod}>
+                      <SelectTrigger className="dark:border-[#3D3D3D] dark:bg-background">
+                        <SelectValue placeholder="Select method" />
+                      </SelectTrigger>
+                      <SelectContent>
+                        <SelectItem value="percentile">Percentile</SelectItem>
+                        <SelectItem value="standard_deviation">Standard Deviation</SelectItem>
+                        <SelectItem value="interquartile">Interquartile</SelectItem>
+                      </SelectContent>
+                    </Select>
+                    <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                      Breakpoint detection method
+                    </p>
+                  </div>
+
+                  <div>
+                    <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                      Semantic Threshold
+                    </label>
+                    <Input
+                      type="number"
+                      step="0.01"
+                      className="dark:border-[#3D3D3D] dark:bg-background"
+                      placeholder="0.95"
+                      value={semanticThreshold}
+                      onChange={(e) => setSemanticThreshold(e.target.value)}
+                    />
+                    <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                      Threshold for detecting breakpoints
+                    </p>
+                  </div>
+                </div>
+              )}
+
+              {/* Settings for regex chunker */}
+              {defaultChunker === "regex" && (
+                <div>
+                  <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                    Regex Pattern
+                  </label>
+                  <Input
+                    type="text"
+                    className="dark:border-[#3D3D3D] dark:bg-background"
+                    placeholder="\r?\n"
+                    value={regexPattern}
+                    onChange={(e) => setRegexPattern(e.target.value)}
+                  />
+                  <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                    Regular expression pattern to split on
+                  </p>
+                </div>
+              )}
+
+              {/* Info for HTML chunker */}
+              {defaultChunker === "html" && (
+                <div className="p-4 rounded-lg bg-blue-50 dark:bg-blue-900/20 text-blue-800 dark:text-blue-200">
+                  <p className="text-sm">
+                    HTML chunker uses the document structure to split content. No additional configuration needed.
+                  </p>
+                </div>
+              )}
+            </div>
+          </div>
+
+          {message && (
+            <div
+              className={`p-4 rounded-lg ${
+                messageType === "success"
+                  ? "bg-green-50 dark:bg-green-900/20 text-green-800 dark:text-green-200"
+                  : "bg-red-50 dark:bg-red-900/20 text-red-800 dark:text-red-200"
+              }`}
+            >
+              {message}
+            </div>
+          )}
+
+          {/* Advanced Ingestion Settings */}
+          <div className="bg-white dark:bg-shadeA border border-gray-300 dark:border-[#3D3D3D] rounded-lg p-6">
+            <button
+              type="button"
+              onClick={() => setShowAdvanced(!showAdvanced)}
+              className="w-full flex items-center justify-between"
+            >
+              <h2 className="text-lg font-semibold text-black dark:text-white">
+                Advanced Ingestion Settings
+              </h2>
+              <span className="text-sm text-gray-500 dark:text-gray-400">
+                {showAdvanced ? "▲ Collapse" : "▼ Expand"}
+              </span>
+            </button>
+            {!showAdvanced && (
+              <p className="text-sm text-gray-600 dark:text-[#D9D9D9] mt-2">
+                Performance tuning for document ingestion and batch processing.
+              </p>
+            )}
+
+            {showAdvanced && (
+              <div className="space-y-4 mt-4">
+                <p className="text-sm text-gray-600 dark:text-[#D9D9D9] mb-2">
+                  Performance tuning for document ingestion and batch processing.
+                </p>
+
+                <div className="grid grid-cols-3 gap-4">
+                  <div>
+                    <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                      Batch Size
+                    </label>
+                    <Input
+                      type="number"
+                      min="1"
+                      className="dark:border-[#3D3D3D] dark:bg-background"
+                      placeholder="500"
+                      value={loadBatchSize}
+                      onChange={(e) => setLoadBatchSize(e.target.value)}
+                    />
+                    <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                      Vertices per upsert batch
+                    </p>
+                  </div>
+
+                  <div>
+                    <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                      Upsert Delay
+                    </label>
+                    <Input
+                      type="number"
+                      min="0"
+                      className="dark:border-[#3D3D3D] dark:bg-background"
+                      placeholder="0"
+                      value={upsertDelay}
+                      onChange={(e) => setUpsertDelay(e.target.value)}
+                    />
+                    <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                      Seconds between batches
+                    </p>
+                  </div>
+
+                  <div>
+                    <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                      Default Concurrency
+                    </label>
+                    <Input
+                      type="number"
+                      min="1"
+                      className="dark:border-[#3D3D3D] dark:bg-background"
+                      placeholder="10"
+                      value={maxConcurrency}
+                      onChange={(e) => setMaxConcurrency(e.target.value)}
+                    />
+                    <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                      Max concurrent workers for graph queries, LLM, and embedding calls
+                    </p>
+                  </div>
+                </div>
+              </div>
+            )}
+          </div>
+
+          {/* Service Endpoints (global only) */}
+          {configScope !== "graph" && (
+            <div className="bg-white dark:bg-shadeA border border-gray-300 dark:border-[#3D3D3D] rounded-lg p-6">
+              <h2 className="text-lg font-semibold mb-4 text-black dark:text-white">
+                Service Endpoints
+              </h2>
+              <p className="text-sm text-gray-600 dark:text-[#D9D9D9] mb-6">
+                Configure internal service URLs. These are global settings and cannot be overridden per graph.
+              </p>
+
+              <div className="space-y-4">
+                <div>
+                  <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                    ECC Service URL
+                  </label>
+                  <Input
+                    type="text"
+                    className="dark:border-[#3D3D3D] dark:bg-background"
+                    placeholder="http://graphrag-ecc:8001"
+                    value={eccUrl}
+                    onChange={(e) => setEccUrl(e.target.value)}
+                  />
+                  <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                    Entity-Context-Community service endpoint
+                  </p>
+                </div>
+
+                <div>
+                  <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                    Chat History API URL
+                  </label>
+                  <Input
+                    type="text"
+                    className="dark:border-[#3D3D3D] dark:bg-background"
+                    placeholder="http://chat-history:8002"
+                    value={chatHistoryUrl}
+                    onChange={(e) => setChatHistoryUrl(e.target.value)}
+                  />
+                  <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                    Chat history service endpoint
+                  </p>
+                </div>
+              </div>
+            </div>
+          )}
+
+          <Button onClick={handleSave} disabled={isSaving} className="gradient text-white w-full">
+            {isSaving ? (
+              <>
+                <Loader2 className="h-4 w-4 mr-2 animate-spin" />
+                Saving...
+              </>
+            ) : (
+              <>
+                <Save className="h-4 w-4 mr-2" />
+                Save GraphRAG Configuration
+              </>
+            )}
+          </Button>
+        </div>
+        </fieldset>
+      </div>
+    </div>
+  );
+};
+
+export default GraphRAGConfig;
+
diff --git a/graphrag-ui/src/pages/setup/IngestGraph.tsx b/graphrag-ui/src/pages/setup/IngestGraph.tsx
new file mode 100644
index 0000000..db9677a
--- /dev/null
+++ b/graphrag-ui/src/pages/setup/IngestGraph.tsx
@@ -0,0 +1,1591 @@
+import React, { useState, useEffect, useRef } from "react";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import {
+  Upload,
+  Loader2,
+  Trash2,
+  FolderUp,
+  CloudDownload,
+  CloudLightning,
+  Database,
+} from "lucide-react";
+import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import { useConfirm } from "@/hooks/useConfirm";
+import { pauseIdleTimer, resumeIdleTimer } from "@/hooks/useIdleTimeout";
+
+interface IngestGraphProps {
+  isModal?: boolean;
+}
+
+const DEFAULT_MAX_UPLOAD_SIZE_MB = 100;
+const envUploadLimit = Number(import.meta.env.VITE_MAX_UPLOAD_SIZE_MB);
+const MAX_UPLOAD_SIZE_MB =
+  Number.isFinite(envUploadLimit) && envUploadLimit > 0
+    ? envUploadLimit
+    : DEFAULT_MAX_UPLOAD_SIZE_MB;
+const MAX_UPLOAD_SIZE_BYTES = MAX_UPLOAD_SIZE_MB * 1024 * 1024;
+
+const formatBytes = (bytes: number) => {
+  if (bytes === 0) return "0 Bytes";
+  const units = ["Bytes", "KB", "MB", "GB", "TB"];
+  const exponent = Math.floor(Math.log(bytes) / Math.log(1024));
+  const value = bytes / Math.pow(1024, exponent);
+  const rounded =
+    value >= 10 || exponent === 0 ? value.toFixed(0) : value.toFixed(1);
+  return `${rounded} ${units[exponent]}`;
+};
+
+const IngestGraph: React.FC<IngestGraphProps> = ({ isModal = false }) => {
+  const [confirm, confirmDialog] = useConfirm();
+  const [availableGraphs, setAvailableGraphs] = useState<string[]>([]);
+  const [ingestGraphName, setIngestGraphName] = useState("");
+  const [selectedFiles, setSelectedFiles] = useState<FileList | null>(null);
+  const fileInputRef = useRef<HTMLInputElement>(null);
+  const [uploadedFiles, setUploadedFiles] = useState<any[]>([]);
+  const [isUploading, setIsUploading] = useState(false);
+  const [uploadMessage, setUploadMessage] = useState("");
+  const [isProcessingFiles, setIsProcessingFiles] = useState(false);
+  const [isIngesting, setIsIngesting] = useState(false);
+  const [ingestMessage, setIngestMessage] = useState("");
+  const [ingestJobData, setIngestJobData] = useState<any>(null);
+  const [directIngestion, setDirectIngestion] = useState(false);
+  const [activeTab, setActiveTab] = useState("upload");
+
+  // S3 state
+  const [awsAccessKey, setAwsAccessKey] = useState("");
+  const [awsSecretKey, setAwsSecretKey] = useState("");
+  const [inputBucket, setInputBucket] = useState("");
+  const [outputBucket, setOutputBucket] = useState("");
+  const [regionName, setRegionName] = useState("");
+  const [skipBDAProcessing, setSkipBDAProcessing] = useState(false);
+
+  // Cloud Download state
+  const [cloudProvider, setCloudProvider] = useState<"s3" | "gcs" | "azure">("s3");
+  const [cloudAccessKey, setCloudAccessKey] = useState("");
+  const [cloudSecretKey, setCloudSecretKey] = useState("");
+  const [cloudBucket, setCloudBucket] = useState("");
+  const [cloudRegion, setCloudRegion] = useState("");
+  const [cloudPrefix, setCloudPrefix] = useState("");
+  // GCS specific
+  const [gcsProjectId, setGcsProjectId] = useState("");
+  const [gcsCredentials, setGcsCredentials] = useState("");
+  // Azure specific
+  const [azureAccountName, setAzureAccountName] = useState("");
+  const [azureAccountKey, setAzureAccountKey] = useState("");
+  const [azureContainer, setAzureContainer] = useState("");
+  // Cloud download files state
+  const [downloadedFiles, setDownloadedFiles] = useState<any[]>([]);
+  const [isDownloading, setIsDownloading] = useState(false);
+  const [downloadMessage, setDownloadMessage] = useState("");
+
+  // Fetch uploaded files
+  const fetchUploadedFiles = async () => {
+    if (!ingestGraphName) return;
+
+    try {
+      const creds = sessionStorage.getItem("creds");
+      const response = await fetch(`/ui/${ingestGraphName}/uploads/list`, {
+        headers: { Authorization: `Basic ${creds}` },
+      });
+      const data = await response.json();
+      setUploadedFiles(data.files || []);
+    } catch (error) {
+      console.error("Error fetching files:", error);
+    }
+  };
+
+  // Upload files
+  const handleUploadFiles = async () => {
+    if (!selectedFiles || selectedFiles.length === 0) {
+      setUploadMessage("Please select files to upload");
+      return;
+    }
+
+    if (!ingestGraphName) {
+      setUploadMessage("Please enter a graph name");
+      return;
+    }
+
+    const filesArray = Array.from(selectedFiles);
+
+    // Check if any single file exceeds the server limit
+    const oversizedFiles = filesArray.filter(
+      (file) => file.size > MAX_UPLOAD_SIZE_BYTES
+    );
+    if (oversizedFiles.length > 0) {
+      const names = oversizedFiles
+        .map((file) => `${file.name} (${formatBytes(file.size)})`)
+        .join(", ");
+      setUploadMessage(
+        `❌ ${names} ${
+          oversizedFiles.length === 1 ? "exceeds" : "exceed"
+        } the ${MAX_UPLOAD_SIZE_MB} MB limit per file. ` +
+          `Please split or compress ${
+            oversizedFiles.length === 1 ? "this file" : "these files"
+          }.`
+      );
+      return;
+    }
+
+    const totalSize = filesArray.reduce((sum, file) => sum + file.size, 0);
+
+    // If total size exceeds limit and we have multiple files, upload one by one
+    if (totalSize > MAX_UPLOAD_SIZE_BYTES && filesArray.length > 1) {
+      await handleBatchUpload(filesArray);
+      return;
+    }
+
+    // Single file or files within limit - upload normally
+    setIsUploading(true);
+    setUploadMessage("Uploading files...");
+    setIngestMessage("");
+
+    try {
+      const creds = sessionStorage.getItem("creds");
+      const formData = new FormData();
+      filesArray.forEach((file) => formData.append("files", file));
+
+      const response = await fetch(
+        `/ui/${ingestGraphName}/uploads?overwrite=true`,
+        {
+          method: "POST",
+          headers: { Authorization: `Basic ${creds}` },
+          body: formData,
+        }
+      );
+
+      if (!response.ok) {
+        const errorData = await response.json();
+        throw new Error(errorData.detail || `Upload failed: ${response.statusText}`);
+      }
+
+      const data = await response.json();
+      if (data.status === "success") {
+        const uploadedCount = selectedFiles?.length || 0;
+        setUploadMessage("✅ Successfully uploaded the files. Processing...");
+        setSelectedFiles(null);
+        if (fileInputRef.current) fileInputRef.current.value = "";
+        await fetchUploadedFiles();
+        setIsUploading(false);
+
+        console.log("Calling handleCreateIngestAfterUpload from main upload...");
+        setIsProcessingFiles(true);
+        handleCreateIngestAfterUpload("uploaded", uploadedCount).catch((err) => {
+          console.error("Error in background processing:", err);
+          setUploadMessage(`❌ Processing error: ${err.message}`);
+        }).finally(() => setIsProcessingFiles(false));
+      } else {
+        setUploadMessage(`⚠️ ${data.message}`);
+        setIsUploading(false);
+      }
+    } catch (error: any) {
+      console.error("Upload error:", error);
+      const isLockConflict = error.message?.includes("currently being processed");
+      setUploadMessage(isLockConflict ? `⚠️ ${error.message}` : `❌ Error: ${error.message}`);
+      setIsUploading(false);
+    }
+  };
+
+  // Handle batch upload when total size exceeds limit - upload one file at a time
+  const handleBatchUpload = async (filesArray: File[]) => {
+    setIsUploading(true);
+    setUploadMessage("Total size exceeds limit. Uploading files one by one...");
+    setIngestMessage("");
+
+    try {
+      const creds = sessionStorage.getItem("creds");
+      let uploadedCount = 0;
+      let failedCount = 0;
+      const totalFiles = filesArray.length;
+
+      // Upload files one at a time to avoid 413 errors
+      for (let i = 0; i < filesArray.length; i++) {
+        const file = filesArray[i];
+        const fileNumber = i + 1;
+
+        setUploadMessage(
+          `Uploading file ${fileNumber}/${totalFiles}: ${file.name} (${formatBytes(
+            file.size
+          )})...`
+        );
+
+        const formData = new FormData();
+        formData.append("files", file);
+
+        try {
+          const response = await fetch(
+            `/ui/${ingestGraphName}/uploads?overwrite=true`,
+            {
+              method: "POST",
+              headers: { Authorization: `Basic ${creds}` },
+              body: formData,
+            }
+          );
+
+          if (!response.ok) {
+            throw new Error(`Upload failed with status ${response.status}`);
+          }
+
+          const data = await response.json();
+          if (data.status === "success") {
+            uploadedCount++;
+          } else {
+            failedCount++;
+            console.error(`File ${file.name} failed:`, data);
+          }
+        } catch (err) {
+          console.error(`File ${file.name} error:`, err);
+          failedCount++;
+        }
+      }
+
+      // Show final result
+      if (failedCount === 0) {
+        setUploadMessage(`✅ Successfully uploaded all ${uploadedCount} files. Processing...`);
+      } else {
+        setUploadMessage(`⚠️ Uploaded ${uploadedCount} files successfully, ${failedCount} failed. Processing...`);
+      }
+
+      setSelectedFiles(null);
+      if (fileInputRef.current) fileInputRef.current.value = "";
+      await fetchUploadedFiles();
+
+      console.log("Calling handleCreateIngestAfterUpload...");
+      setIsProcessingFiles(true);
+      try {
+        await handleCreateIngestAfterUpload("uploaded", uploadedCount);
+        console.log("handleCreateIngestAfterUpload completed");
+      } finally {
+        setIsProcessingFiles(false);
+      }
+    } catch (error: any) {
+      console.error("Upload error:", error);
+      setUploadMessage(`❌ Batch upload error: ${error.message}`);
+    } finally {
+      setIsUploading(false);
+    }
+  };
+
+  // Delete a specific file
+  const handleDeleteFile = async (filename: string) => {
+    if (!ingestGraphName) return;
+
+    try {
+      const creds = sessionStorage.getItem("creds");
+      const response = await fetch(
+        `/ui/${ingestGraphName}/uploads?filename=${encodeURIComponent(filename)}`,
+        {
+          method: "DELETE",
+          headers: { Authorization: `Basic ${creds}` },
+        }
+      );
+      const data = await response.json();
+      setUploadMessage(`✅ ${data.message}`);
+      await fetchUploadedFiles();
+    } catch (error: any) {
+      setUploadMessage(`❌ Error: ${error.message}`);
+    }
+  };
+
+  // Delete all files
+  const handleDeleteAllFiles = async () => {
+    if (!ingestGraphName) return;
+
+    const shouldDelete = await confirm(
+      "Are you sure you want to delete all uploaded files?"
+    );
+    if (!shouldDelete) return;
+
+    try {
+      const creds = sessionStorage.getItem("creds");
+      const response = await fetch(`/ui/${ingestGraphName}/uploads`, {
+        method: "DELETE",
+        headers: { Authorization: `Basic ${creds}` },
+      });
+      const data = await response.json();
+      setUploadMessage(`✅ ${data.message}`);
+      await fetchUploadedFiles();
+    } catch (error: any) {
+      setUploadMessage(`❌ Error: ${error.message}`);
+    }
+  };
+
+  // Fetch downloaded files from cloud
+  const fetchDownloadedFiles = async () => {
+    if (!ingestGraphName) return;
+
+    try {
+      const creds = sessionStorage.getItem("creds");
+      const response = await fetch(`/ui/${ingestGraphName}/cloud/list`, {
+        headers: { Authorization: `Basic ${creds}` },
+      });
+      const data = await response.json();
+      setDownloadedFiles(data.files || []);
+    } catch (error) {
+      console.error("Error fetching downloaded files:", error);
+    }
+  };
+
+  // Handle cloud download
+  const handleCloudDownload = async () => {
+    if (!ingestGraphName) {
+      setDownloadMessage("Please select a graph");
+      return;
+    }
+
+    setIsDownloading(true);
+    setDownloadMessage("Downloading files from cloud storage...");
+
+    try {
+      const creds = sessionStorage.getItem("creds");
+
+      // Prepare request body based on provider
+      let requestBody: any = { provider: cloudProvider };
+
+      if (cloudProvider === "s3") {
+        if (!cloudAccessKey || !cloudSecretKey || !cloudBucket || !cloudRegion) {
+          setDownloadMessage("❌ Please fill in all S3 credentials");
+          setIsDownloading(false);
+          return;
+        }
+        requestBody = {
+          ...requestBody,
+          access_key: cloudAccessKey,
+          secret_key: cloudSecretKey,
+          bucket: cloudBucket,
+          region: cloudRegion,
+          prefix: cloudPrefix,
+        };
+      } else if (cloudProvider === "gcs") {
+        if (!gcsProjectId || !gcsCredentials || !cloudBucket) {
+          setDownloadMessage("❌ Please fill in all GCS credentials");
+          setIsDownloading(false);
+          return;
+        }
+        requestBody = {
+          ...requestBody,
+          project_id: gcsProjectId,
+          gcs_credentials_json: gcsCredentials,
+          bucket: cloudBucket,
+          prefix: cloudPrefix,
+        };
+      } else if (cloudProvider === "azure") {
+        if (!azureAccountName || !azureAccountKey || !azureContainer) {
+          setDownloadMessage("❌ Please fill in all Azure credentials");
+          setIsDownloading(false);
+          return;
+        }
+        requestBody = {
+          ...requestBody,
+          account_name: azureAccountName,
+          account_key: azureAccountKey,
+          container: azureContainer,
+          prefix: cloudPrefix,
+        };
+      }
+
+      const response = await fetch(`/ui/${ingestGraphName}/cloud/download`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Basic ${creds}`,
+        },
+        body: JSON.stringify(requestBody),
+      });
+
+      if (!response.ok) {
+        const errorData = await response.json();
+        throw new Error(errorData.detail || `Download failed: ${response.statusText}`);
+      }
+      const data = await response.json();
+      if (data.status === "success") {
+        const downloadCount = data.downloaded_files?.length || downloadedFiles.length;
+        setDownloadMessage("✅ Successfully downloaded the files. Processing...");
+        await fetchDownloadedFiles();
+        setIsDownloading(false);
+        setIsProcessingFiles(true);
+        handleCreateIngestAfterUpload("downloaded", downloadCount).catch((err) => {
+          console.error("Error in background processing:", err);
+          setDownloadMessage(`❌ Processing error: ${err.message}`);
+        }).finally(() => setIsProcessingFiles(false));
+      } else if (data.status === "warning") {
+        setDownloadMessage(`⚠️ ${data.message}`);
+        setIsDownloading(false);
+      } else {
+        setDownloadMessage(`❌ ${data.message || "Download failed"}`);
+        setIsDownloading(false);
+      }
+    } catch (error: any) {
+      const isLockConflict = error.message?.includes("currently being processed");
+      setDownloadMessage(isLockConflict ? `⚠️ ${error.message}` : `❌ Error: ${error.message}`);
+    } finally {
+      setIsDownloading(false);
+    }
+  };
+
+  // Delete a specific downloaded file
+  const handleDeleteDownloadedFile = async (filename: string) => {
+    if (!ingestGraphName) return;
+
+    try {
+      const creds = sessionStorage.getItem("creds");
+      const response = await fetch(
+        `/ui/${ingestGraphName}/cloud/delete?filename=${encodeURIComponent(
+          filename
+        )}`,
+        {
+          method: "DELETE",
+          headers: { Authorization: `Basic ${creds}` },
+        }
+      );
+      const data = await response.json();
+      setDownloadMessage(`✅ ${data.message}`);
+      await fetchDownloadedFiles();
+    } catch (error: any) {
+      setDownloadMessage(`❌ Error: ${error.message}`);
+    }
+  };
+
+  // Delete all downloaded files
+  const handleDeleteAllDownloadedFiles = async () => {
+    if (!ingestGraphName) return;
+
+    const shouldDelete = await confirm(
+      "Are you sure you want to delete all downloaded files?"
+    );
+    if (!shouldDelete) return;
+
+    try {
+      const creds = sessionStorage.getItem("creds");
+      const response = await fetch(`/ui/${ingestGraphName}/cloud/delete`, {
+        method: "DELETE",
+        headers: { Authorization: `Basic ${creds}` },
+      });
+      const data = await response.json();
+      setDownloadMessage(`✅ ${data.message}`);
+      await fetchDownloadedFiles();
+    } catch (error: any) {
+      setDownloadMessage(`❌ Error: ${error.message}`);
+    }
+  };
+
+  const handleRunIngest = async (sourceType: "uploaded" | "downloaded" = "uploaded") => {
+    if (!ingestGraphName) {
+      setIngestMessage("❌ Please select a graph");
+      return;
+    }
+    setIsIngesting(true);
+    setIngestMessage("Ingesting documents into knowledge graph...");
+    try {
+      const creds = sessionStorage.getItem("creds");
+      const folderPath = sourceType === "uploaded" ? `uploads/${ingestGraphName}` : `downloaded_files_cloud/${ingestGraphName}`;
+
+      // Use existing ingestJobData if available, otherwise construct from folder path
+      const jobData = ingestJobData || {
+        load_job_id: "load_documents_content_json",
+        data_source_id: {
+          data_source: "server",
+          data_source_config: { data_path: folderPath },
+          loader_config: {},
+          file_format: "multi"
+        },
+        data_path: folderPath,
+      };
+
+      const ingestResponse = await fetch(`/ui/${ingestGraphName}/ingest`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Basic ${creds}`,
+        },
+        body: JSON.stringify({
+          load_job_id: jobData.load_job_id,
+          data_source_id: jobData.data_source_id,
+          file_path: jobData.data_path,
+        }),
+      });
+
+      if (!ingestResponse.ok) {
+        const errorData = await ingestResponse.json();
+        throw new Error(errorData.detail || `Failed to ingest: ${ingestResponse.statusText}`);
+      }
+
+      const ingestData = await ingestResponse.json();
+      console.log("Ingest response:", ingestData);
+
+      setIngestMessage(`✅ Ingestion completed successfully!`);
+      setUploadMessage("");
+    } catch (error: any) {
+      console.error("Error during ingestion:", error);
+      const isRebuildConflict = error.message?.includes("currently being rebuilt");
+      setIngestMessage(isRebuildConflict ? `⚠️ ${error.message}` : `❌ Error: ${error.message}`);
+    } finally {
+      setIsIngesting(false);
+    }
+  };
+
+  // Ingest files into knowledge graph (uploaded or downloaded)
+  const handleIngestDocuments = async (sourceType: "uploaded" | "downloaded" = "uploaded") => {
+    if (!ingestGraphName) {
+      setIngestMessage("Please select a graph");
+      return;
+    }
+
+    const folderPath = sourceType === "uploaded" ? `uploads/${ingestGraphName}` : `downloaded_files_cloud/${ingestGraphName}`;
+    const fileCount = sourceType === "uploaded" ? uploadedFiles.length : downloadedFiles.length;
+
+    setIsIngesting(true);
+    setIngestMessage("Step 1/2: Creating ingest job...");
+
+    try {
+      const creds = sessionStorage.getItem("creds");
+
+      const createIngestConfig = {
+        data_source: "server",
+        data_source_config: { data_path: folderPath },
+        loader_config: {},
+        file_format: "multi",
+      };
+
+      const createResponse = await fetch(`/ui/${ingestGraphName}/create_ingest`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Basic ${creds}`,
+        },
+        body: JSON.stringify(createIngestConfig),
+      });
+
+      if (!createResponse.ok) {
+        const errorData = await createResponse.json();
+        throw new Error(errorData.detail || `Failed to create ingest job: ${createResponse.statusText}`);
+      }
+
+      const createData = await createResponse.json();
+      console.log("Create ingest response:", createData);
+
+      // Store ingest job data for later use
+      setIngestJobData({
+        load_job_id: createData.load_job_id,
+        data_source_id: createData.data_source_id,
+        data_path: folderPath,
+      });
+
+      if (!directIngestion) {
+        setIngestMessage(`✅ ${fileCount} file(s) ready for ingestion.`);
+        setIsIngesting(false);
+      } else {
+        setIngestMessage("Step 2/2: Running document ingest...");
+        const loadingInfo = {
+          load_job_id: createData.load_job_id,
+          data_source_id: createData.data_source_id,
+          file_path: createData.data_path || createData.file_path,
+        };
+
+        const ingestResponse = await fetch(`/ui/${ingestGraphName}/ingest`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Basic ${creds}`,
+          },
+          body: JSON.stringify(loadingInfo),
+        });
+
+        if (!ingestResponse.ok) {
+          const errorData = await ingestResponse.json();
+          throw new Error(errorData.detail || `Failed to run ingest: ${ingestResponse.statusText}`);
+        }
+
+        const ingestData = await ingestResponse.json();
+        console.log("Ingest response:", ingestData);
+
+        setIngestMessage(`✅ Data ingested successfully! Processed documents from ${folderPath}/`);
+        setIsIngesting(false);
+      }
+    } catch (error: any) {
+      console.error("Error ingesting data:", error);
+      const isRebuildConflict = error.message?.includes("currently being rebuilt");
+      setIngestMessage(isRebuildConflict ? `⚠️ ${error.message}` : `❌ Error: ${error.message}`);
+      setIsIngesting(false);
+    }
+  };
+
+  // Called automatically after upload or cloud download finishes
+  const handleCreateIngestAfterUpload = async (sourceType: "uploaded" | "downloaded" = "uploaded", fileCountParam?: number) => {
+    console.log("handleCreateIngestAfterUpload called with sourceType:", sourceType);
+    console.log("ingestGraphName:", ingestGraphName);
+
+    if (!ingestGraphName) {
+      console.log("No graph name, returning early");
+      return;
+    }
+
+    const folderPath = sourceType === "uploaded" ? `uploads/${ingestGraphName}` : `downloaded_files_cloud/${ingestGraphName}`;
+    const fileCount = fileCountParam || (sourceType === "uploaded" ? uploadedFiles.length : downloadedFiles.length);
+    console.log("folderPath:", folderPath);
+    console.log("fileCount:", fileCount);
+
+    try {
+      const creds = sessionStorage.getItem("creds");
+
+      const createIngestConfig = {
+        data_source: "server",
+        data_source_config: { data_path: folderPath },
+        loader_config: {},
+        file_format: "multi",
+      };
+
+      console.log("Calling create_ingest with config:", createIngestConfig);
+
+      const createResponse = await fetch(`/ui/${ingestGraphName}/create_ingest`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Basic ${creds}`,
+        },
+        body: JSON.stringify(createIngestConfig),
+      });
+
+      console.log("create_ingest response status:", createResponse.status);
+
+      if (!createResponse.ok) {
+        const errorData = await createResponse.json();
+        console.error("create_ingest error:", errorData);
+        throw new Error(errorData.detail || `Failed to create ingest job: ${createResponse.statusText}`);
+      }
+
+      const createData = await createResponse.json();
+      console.log("create_ingest response data:", createData);
+
+      setIngestJobData({
+        load_job_id: createData.load_job_id,
+        data_source_id: createData.data_source_id,
+        data_path: folderPath,
+      });
+
+      console.log("Direct ingestion enabled:", directIngestion);
+
+      if (directIngestion) {
+        if (sourceType === "uploaded") {
+          setUploadMessage("Running direct ingestion...");
+        } else {
+          setDownloadMessage("Running direct ingestion...");
+        }
+        await handleRunIngest(sourceType);
+      } else {
+        if (sourceType === "uploaded") {
+          setUploadMessage(`✅ ${fileCount} file(s) ready for ingestion.`);
+        } else {
+          setDownloadMessage(`✅ ${fileCount} file(s) ready for ingestion.`);
+        }
+      }
+    } catch (error: any) {
+      console.error("Error in create_ingest:", error);
+      if (sourceType === "uploaded") {
+        setUploadMessage(`❌ Processing error: ${error.message}`);
+      } else {
+        setDownloadMessage(`❌ Processing error: ${error.message}`);
+      }
+    }
+  };
+
+  // Ingest files from S3 with Amazon BDA
+  const handleAmazonBDAIngest = async () => {
+    if (!ingestGraphName) {
+      setIngestMessage("Please select a graph");
+      return;
+    }
+
+    // Validate inputs based on file format
+    if (!awsAccessKey || !awsSecretKey) {
+      setIngestMessage("❌ Please provide AWS Access Key and Secret Key");
+      return;
+    }
+
+    if (skipBDAProcessing) {
+      // When skipping BDA, only output bucket and region are required
+      if (!outputBucket || !regionName) {
+        setIngestMessage("❌ Please provide Output Bucket and Region Name");
+        return;
+      }
+    } else {
+      // When using BDA, all fields are required
+      if (!inputBucket || !outputBucket || !regionName) {
+        setIngestMessage(
+          "❌ Please provide Input Bucket, Output Bucket, and Region Name"
+        );
+        return;
+      }
+    }
+
+    // Ask for confirmation
+    const confirmMessage = skipBDAProcessing
+      ? `You're skipping Amazon BDA processing and will ingest directly from the output bucket (${outputBucket}). Please confirm to proceed.`
+      : `You're using Amazon BDA for multimodal document processing. This will trigger Amazon BDA to process your documents from the input bucket (${inputBucket}) and store the results in the output bucket (${outputBucket}) and then ingest them into your knowledge graph. Please confirm to proceed.`;
+
+    const shouldProceed = await confirm(confirmMessage);
+    if (!shouldProceed) {
+      setIngestMessage("Operation cancelled by user.");
+      return;
+    }
+
+    setIsIngesting(true);
+
+    try {
+      const creds = sessionStorage.getItem("creds");
+      let loadingInfo: any = {};
+
+      if (skipBDAProcessing) {
+        // Skip BDA processing - create ingest job that reads directly from output bucket
+        const runIngestConfig: any = {
+          data_source: "bda",
+          aws_access_key: awsAccessKey,
+          aws_secret_key: awsSecretKey,
+          output_bucket: outputBucket,
+          region_name: regionName,
+          bda_jobs: [],
+          loader_config: {
+            doc_id_field: "doc_id",
+            content_field: "content",
+            doc_type: "markdown",
+          },
+          file_format: "multi",
+        };
+
+        setIngestMessage("Step 1/2: Creating ingest job from output bucket...");
+
+        // Run ingest directly
+        loadingInfo = {
+          load_job_id: "load_documents_content_json",
+          data_source_id: runIngestConfig,
+          file_path: outputBucket,
+        };
+        setIngestMessage(
+          `Step 2/2: Running document ingestion for all files in ${outputBucket}...`
+        );
+      } else {
+        // Step 1: Create ingest job with BDA processing
+        const createIngestConfig: any = {
+          data_source: "bda",
+          data_source_config: {
+            aws_access_key: awsAccessKey,
+            aws_secret_key: awsSecretKey,
+            input_bucket: inputBucket,
+            output_bucket: outputBucket,
+            region_name: regionName,
+          },
+          loader_config: {
+            doc_id_field: "doc_id",
+            content_field: "content",
+            doc_type: "markdown",
+          },
+          file_format: "multi",
+        };
+
+        setIngestMessage(
+          "Step 1/2: Triggering Amazon BDA processing and creating ingest job..."
+        );
+
+        const createResponse = await fetch(
+          `/ui/${ingestGraphName}/create_ingest`,
+          {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Basic ${creds}`,
+            },
+            body: JSON.stringify(createIngestConfig),
+          }
+        );
+
+        if (!createResponse.ok) {
+          const errorData = await createResponse.json();
+          throw new Error(
+            errorData.detail ||
+              `Failed to create ingest job: ${createResponse.statusText}`
+          );
+        }
+
+        const createData = await createResponse.json();
+
+        // Step 2: Run ingest
+        loadingInfo = {
+          load_job_id: createData.load_job_id,
+          data_source_id: createData.data_source_id,
+          file_path: outputBucket,
+        };
+
+        const filesToIngest = createData.data_source_id.bda_jobs.map(
+          (job: any) => job.jobId.split("/").at(-1)
+        );
+        setIngestMessage(
+          `Step 2/2: Running document ingest for ${filesToIngest.length} files in ${outputBucket}...`
+        );
+      }
+
+      const ingestResponse = await fetch(`/ui/${ingestGraphName}/ingest`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Basic ${creds}`,
+        },
+        body: JSON.stringify(loadingInfo),
+      });
+
+      if (!ingestResponse.ok) {
+        const errorData = await ingestResponse.json();
+        throw new Error(
+          errorData.detail || `Failed to run ingest: ${ingestResponse.statusText}`
+        );
+      }
+
+      const ingestData = await ingestResponse.json();
+      const filesIngested = ingestData.summary.map((file: any) => file.file_path);
+
+      setIngestMessage(
+        `✅ Document ingestion completed successfully! Ingested ${filesIngested.length} into your knowledge graph.`
+      );
+    } catch (error: any) {
+      console.error("Error ingesting files:", error);
+      setIngestMessage(`❌ Error: ${error.message}`);
+    } finally {
+      setIsIngesting(false);
+    }
+  };
+
+  // Pause idle timer while ingestion is running
+  useEffect(() => {
+    if (isIngesting) {
+      pauseIdleTimer();
+    } else {
+      resumeIdleTimer();
+    }
+  }, [isIngesting]);
+
+  // Load available graphs from sessionStorage on mount
+  useEffect(() => {
+    const store = JSON.parse(sessionStorage.getItem("site") || "{}");
+    if (store.graphs && Array.isArray(store.graphs)) {
+      setAvailableGraphs(store.graphs);
+      // Auto-select first graph if available
+      if (store.graphs.length > 0 && !ingestGraphName) {
+        setIngestGraphName(store.graphs[0]);
+      }
+    }
+  }, []);
+
+  // Load files when graph name changes
+  useEffect(() => {
+    if (ingestGraphName) {
+      fetchUploadedFiles();
+      fetchDownloadedFiles();
+    }
+  }, [ingestGraphName]);
+
+  return (
+    <div className={isModal ? "" : "p-8"}>
+      <div className={isModal ? "" : "max-w-5xl mx-auto"}>
+        {!isModal && (
+          <>
+            <div className="mb-6">
+              <h1 className="text-2xl font-bold text-black dark:text-white mb-2">
+                Ingest to Knowledge Graph
+              </h1>
+              <p className="text-sm text-gray-600 dark:text-[#D9D9D9]">
+                Upload and ingest documents into your knowledge graph for future content processing
+              </p>
+            </div>
+          </>
+        )}
+
+        <div className="bg-white dark:bg-shadeA border border-gray-300 dark:border-[#3D3D3D] rounded-lg p-6">
+          {/* Graph Name Selection */}
+          <div className="mb-4">
+            <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+              Target Graph Name
+            </label>
+            <Select
+              value={ingestGraphName}
+              onValueChange={setIngestGraphName}
+              disabled={isIngesting}
+            >
+              <SelectTrigger
+                className="dark:border-[#3D3D3D] dark:bg-shadeA"
+                disabled={isIngesting}
+              >
+                <SelectValue placeholder="Select a graph" />
+              </SelectTrigger>
+              <SelectContent>
+                {availableGraphs.length > 0 ? (
+                  availableGraphs.map((graph) => (
+                    <SelectItem key={graph} value={graph}>
+                      {graph}
+                    </SelectItem>
+                  ))
+                ) : (
+                  <SelectItem value="no-graphs" disabled>
+                    No graphs available
+                  </SelectItem>
+                )}
+              </SelectContent>
+            </Select>
+          </div>
+
+          <Tabs
+            value={activeTab}
+            onValueChange={(value) => {
+              // Block tab switching when ingesting
+              if (!isIngesting) {
+                setActiveTab(value);
+              }
+            }}
+            className="w-full"
+          >
+            <TabsList className="grid w-full grid-cols-3">
+              <TabsTrigger value="upload" disabled={isIngesting}>
+                <FolderUp className="h-4 w-4 mr-2" />
+                Upload Files
+              </TabsTrigger>
+              <TabsTrigger value="cloudDownload" disabled={isIngesting}>
+                <CloudDownload className="h-4 w-4 mr-2" />
+                Download from Cloud
+              </TabsTrigger>
+              <TabsTrigger value="AmazonBDA" disabled={isIngesting}>
+                <CloudLightning className="h-4 w-4 mr-2" />
+                Use Amazon BDA
+              </TabsTrigger>
+            </TabsList>
+
+            {/* Upload Data Tab */}
+            <TabsContent value="upload" className="space-y-4">
+              <div className="space-y-4">
+                <p className="text-sm font-medium text-gray-500 dark:text-gray-400 mb-3">
+                  Upload local files to the server and ingest them into your knowledge
+                  graph.
+                </p>
+                <div>
+                  <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                    Select Files
+                  </label>
+                  <input
+                    ref={fileInputRef}
+                    type="file"
+                    multiple
+                    onChange={(e) => setSelectedFiles(e.target.files)}
+                    disabled={isUploading}
+                    className="hidden"
+                  />
+                  <div className="flex items-center gap-3">
+                    <Button
+                      type="button"
+                      variant="outline"
+                      onClick={() => fileInputRef.current?.click()}
+                      disabled={isUploading}
+                      className="border-blue-500 text-blue-600 hover:bg-blue-50 dark:border-blue-400 dark:text-blue-400 dark:hover:bg-blue-900/20"
+                    >
+                      <FolderUp className="h-4 w-4 mr-2" />
+                      Choose Files
+                    </Button>
+                    <span className="text-sm italic text-gray-400 dark:text-gray-500">
+                      {selectedFiles && selectedFiles.length > 0
+                        ? `${selectedFiles.length} file${selectedFiles.length > 1 ? "s" : ""} selected`
+                        : "No files selected"}
+                    </span>
+                  </div>
+                  <p className="text-xs text-gray-500 dark:text-gray-400 mt-2">
+                    Maximum upload per request: {MAX_UPLOAD_SIZE_MB} MB.{" "}
+                    {ingestGraphName
+                      ? `Upload destination: uploads/${ingestGraphName}/`
+                      : ""}
+                  </p>
+                </div>
+
+                <div className="flex gap-2">
+                  <Button
+                    onClick={handleUploadFiles}
+                    disabled={isUploading || isProcessingFiles || !selectedFiles}
+                    className="gradient text-white"
+                  >
+                    {isUploading ? (
+                      <>
+                        <Loader2 className="h-4 w-4 mr-2 animate-spin" />
+                        Uploading...
+                      </>
+                    ) : (
+                      <>
+                        <Upload className="h-4 w-4 mr-2" />
+                        Upload Files
+                      </>
+                    )}
+                  </Button>
+
+                  {uploadedFiles.length > 0 && (
+                    <Button
+                      onClick={handleDeleteAllFiles}
+                      variant="outline"
+                      disabled={isProcessingFiles || isIngesting}
+                      className="dark:border-[#3D3D3D]"
+                    >
+                      <Trash2 className="h-4 w-4 mr-2" />
+                      Delete All
+                    </Button>
+                  )}
+                </div>
+
+                {uploadMessage && (
+                  <div className="p-3 rounded-lg text-sm bg-blue-50 dark:bg-blue-900/20 text-blue-700 dark:text-blue-300">
+                    {uploadMessage}
+                  </div>
+                )}
+
+                {/* Uploaded Files List */}
+                {uploadedFiles.length > 0 && (
+                  <div className="border border-gray-300 dark:border-[#3D3D3D] rounded-lg p-4">
+                    <h3 className="text-sm font-medium mb-3 text-black dark:text-white">
+                      Uploaded Files ({uploadedFiles.length})
+                    </h3>
+                    <div className="space-y-2 max-h-48 overflow-y-auto">
+                      {uploadedFiles.map((file, index) => (
+                        <div
+                          key={index}
+                          className="flex items-center justify-between p-2 bg-gray-50 dark:bg-shadeA rounded"
+                        >
+                          <span className="text-sm text-black dark:text-white truncate flex-1">
+                            {file.filename}
+                          </span>
+                          <Button
+                            onClick={() => handleDeleteFile(file.filename)}
+                            variant="outline"
+                            size="sm"
+                            disabled={isProcessingFiles || isIngesting}
+                            className="ml-2 dark:border-[#3D3D3D]"
+                          >
+                            <Trash2 className="h-3 w-3" />
+                          </Button>
+                        </div>
+                      ))}
+                    </div>
+                  </div>
+                )}
+
+                {/* Ingest Data Section */}
+                {uploadedFiles.length > 0 && (
+                  <div className="border-t border-gray-300 dark:border-[#3D3D3D] pt-4 mt-4">
+                    <h3 className="text-sm font-medium mb-2 text-black dark:text-white">
+                      Ingest Documents into Knowledge Graph
+                    </h3>
+                    <p className="text-xs text-gray-500 dark:text-gray-400 mb-3">
+                      Process uploaded files and add them to the knowledge graph
+                    </p>
+                    <Button
+                      onClick={() => handleRunIngest("uploaded")}
+                      disabled={isIngesting || isProcessingFiles}
+                      className="gradient text-white w-full"
+                    >
+                      {isIngesting ? (
+                        <>
+                          <Loader2 className="h-4 w-4 mr-2 animate-spin" />
+                          Ingesting...
+                        </>
+                      ) : isProcessingFiles ? (
+                        <>
+                          <Loader2 className="h-4 w-4 mr-2 animate-spin" />
+                          Processing files...
+                        </>
+                      ) : (
+                        <>
+                          <Database className="h-4 w-4 mr-2" />
+                          Ingest Documents into {ingestGraphName}
+                        </>
+                      )}
+                    </Button>
+                    {ingestMessage && (
+                      <div className={`p-3 rounded-lg text-sm mt-3 ${
+                        ingestMessage.includes("✅")
+                          ? "bg-green-50 dark:bg-green-900/20 text-green-700 dark:text-green-300"
+                          : ingestMessage.includes("❌")
+                          ? "bg-red-50 dark:bg-red-900/20 text-red-700 dark:text-red-300"
+                          : "bg-blue-50 dark:bg-blue-900/20 text-blue-700 dark:text-blue-300"
+                      }`}>
+                        {ingestMessage}
+                      </div>
+                    )}
+                  </div>
+                )}
+              </div>
+            </TabsContent>
+
+            {/* Download from Cloud Storage Tab */}
+            <TabsContent value="cloudDownload" className="space-y-4">
+              <div className="space-y-4">
+                <p className="text-sm font-medium text-gray-500 dark:text-gray-400 mb-3">
+                  Download files from cloud storage and ingest them into your knowledge
+                  graph.
+                </p>
+                <div>
+                  <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                    Cloud Storage Provider
+                  </label>
+                  <Select
+                    value={cloudProvider}
+                    onValueChange={(value: "s3" | "gcs" | "azure") =>
+                      setCloudProvider(value)
+                    }
+                  >
+                    <SelectTrigger className="dark:border-[#3D3D3D] dark:bg-shadeA">
+                      <SelectValue placeholder="Select cloud provider" />
+                    </SelectTrigger>
+                    <SelectContent>
+                      <SelectItem value="s3">Amazon S3</SelectItem>
+                      <SelectItem value="gcs">Google Cloud Storage</SelectItem>
+                      <SelectItem value="azure">Azure Blob Storage</SelectItem>
+                    </SelectContent>
+                  </Select>
+                </div>
+
+                {/* Amazon S3 */}
+                {cloudProvider === "s3" && (
+                  <>
+                    <div>
+                      <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                        AWS Access Key
+                      </label>
+                      <Input
+                        type="text"
+                        value={cloudAccessKey}
+                        onChange={(e) => setCloudAccessKey(e.target.value)}
+                        placeholder="Enter AWS access key"
+                        className="dark:border-[#3D3D3D] dark:bg-shadeA"
+                      />
+                    </div>
+                    <div>
+                      <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                        AWS Secret Key
+                      </label>
+                      <Input
+                        type="password"
+                        value={cloudSecretKey}
+                        onChange={(e) => setCloudSecretKey(e.target.value)}
+                        placeholder="Enter AWS secret key"
+                        className="dark:border-[#3D3D3D] dark:bg-shadeA"
+                      />
+                    </div>
+                    <div>
+                      <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                        S3 Bucket Name
+                      </label>
+                      <Input
+                        type="text"
+                        value={cloudBucket}
+                        onChange={(e) => setCloudBucket(e.target.value)}
+                        placeholder="my-bucket-name"
+                        className="dark:border-[#3D3D3D] dark:bg-shadeA"
+                      />
+                    </div>
+                    <div>
+                      <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                        Region
+                      </label>
+                      <Input
+                        type="text"
+                        value={cloudRegion}
+                        onChange={(e) => setCloudRegion(e.target.value)}
+                        placeholder="us-east-1"
+                        className="dark:border-[#3D3D3D] dark:bg-shadeA"
+                      />
+                    </div>
+                    <div>
+                      <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                        Prefix/Path (Optional)
+                      </label>
+                      <Input
+                        type="text"
+                        value={cloudPrefix}
+                        onChange={(e) => setCloudPrefix(e.target.value)}
+                        placeholder="folder/subfolder/"
+                        className="dark:border-[#3D3D3D] dark:bg-shadeA"
+                      />
+                    </div>
+                  </>
+                )}
+
+                {/* Google Cloud Storage */}
+                {cloudProvider === "gcs" && (
+                  <>
+                    <div>
+                      <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                        Project ID
+                      </label>
+                      <Input
+                        type="text"
+                        value={gcsProjectId}
+                        onChange={(e) => setGcsProjectId(e.target.value)}
+                        placeholder="my-project-id"
+                        className="dark:border-[#3D3D3D] dark:bg-shadeA"
+                      />
+                    </div>
+                    <div>
+                      <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                        Service Account JSON
+                      </label>
+                      <textarea
+                        value={gcsCredentials}
+                        onChange={(e) => setGcsCredentials(e.target.value)}
+                        placeholder='{"type": "service_account", ...}'
+                        rows={4}
+                        className="w-full p-2 rounded border dark:border-[#3D3D3D] dark:bg-shadeA text-sm"
+                      />
+                    </div>
+                    <div>
+                      <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                        Bucket Name
+                      </label>
+                      <Input
+                        type="text"
+                        value={cloudBucket}
+                        onChange={(e) => setCloudBucket(e.target.value)}
+                        placeholder="my-gcs-bucket"
+                        className="dark:border-[#3D3D3D] dark:bg-shadeA"
+                      />
+                    </div>
+                    <div>
+                      <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                        Prefix/Path (Optional)
+                      </label>
+                      <Input
+                        type="text"
+                        value={cloudPrefix}
+                        onChange={(e) => setCloudPrefix(e.target.value)}
+                        placeholder="folder/subfolder/"
+                        className="dark:border-[#3D3D3D] dark:bg-shadeA"
+                      />
+                    </div>
+                  </>
+                )}
+
+                {/* Azure Blob Storage */}
+                {cloudProvider === "azure" && (
+                  <>
+                    <div>
+                      <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                        Storage Account Name
+                      </label>
+                      <Input
+                        type="text"
+                        value={azureAccountName}
+                        onChange={(e) => setAzureAccountName(e.target.value)}
+                        placeholder="mystorageaccount"
+                        className="dark:border-[#3D3D3D] dark:bg-shadeA"
+                      />
+                    </div>
+                    <div>
+                      <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                        Account Key
+                      </label>
+                      <Input
+                        type="password"
+                        value={azureAccountKey}
+                        onChange={(e) => setAzureAccountKey(e.target.value)}
+                        placeholder="Enter account key"
+                        className="dark:border-[#3D3D3D] dark:bg-shadeA"
+                      />
+                    </div>
+                    <div>
+                      <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                        Container Name
+                      </label>
+                      <Input
+                        type="text"
+                        value={azureContainer}
+                        onChange={(e) => setAzureContainer(e.target.value)}
+                        placeholder="my-container"
+                        className="dark:border-[#3D3D3D] dark:bg-shadeA"
+                      />
+                    </div>
+                    <div>
+                      <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                        Prefix/Path (Optional)
+                      </label>
+                      <Input
+                        type="text"
+                        value={cloudPrefix}
+                        onChange={(e) => setCloudPrefix(e.target.value)}
+                        placeholder="folder/subfolder/"
+                        className="dark:border-[#3D3D3D] dark:bg-shadeA"
+                      />
+                    </div>
+                  </>
+                )}
+                {ingestGraphName && (
+                  <p className="text-xs text-gray-500 dark:text-gray-400 mb-2">
+                    Download destination: downloaded_files_cloud/{ingestGraphName}/
+                  </p>
+                )}
+
+                <div className="pt-4 border-t border-gray-300 dark:border-[#3D3D3D]">
+                  <Button
+                    onClick={handleCloudDownload}
+                    disabled={isDownloading}
+                    className="gradient text-white w-full"
+                  >
+                    {isDownloading ? (
+                      <>
+                        <Loader2 className="h-4 w-4 mr-2 animate-spin" />
+                        Downloading...
+                      </>
+                    ) : (
+                      <>
+                        <CloudDownload className="h-4 w-4 mr-2" />
+                        Download Files from{" "}
+                        {cloudProvider === "s3"
+                          ? "S3"
+                          : cloudProvider === "gcs"
+                          ? "GCS"
+                          : "Azure"}
+                      </>
+                    )}
+                  </Button>
+                </div>
+
+                {downloadMessage && (
+                  <div
+                    className={`p-3 rounded-lg text-sm mt-3 ${
+                      downloadMessage.includes("✅")
+                        ? "bg-green-50 dark:bg-green-900/20 text-green-700 dark:text-green-300"
+                        : downloadMessage.includes("❌")
+                        ? "bg-red-50 dark:bg-red-900/20 text-red-700 dark:text-red-300"
+                        : "bg-blue-50 dark:bg-blue-900/20 text-blue-700 dark:text-blue-300"
+                    }`}
+                  >
+                    {downloadMessage}
+                  </div>
+                )}
+
+                {/* Downloaded Files List */}
+                {downloadedFiles.length > 0 && (
+                  <div className="mt-4 border-t border-gray-300 dark:border-[#3D3D3D] pt-4">
+                    <div className="flex justify-between items-center mb-2">
+                      <h4 className="text-sm font-medium text-black dark:text-white">
+                        Downloaded Files ({downloadedFiles.length})
+                      </h4>
+                      <Button
+                        onClick={handleDeleteAllDownloadedFiles}
+                        variant="outline"
+                        size="sm"
+                        className="dark:border-[#3D3D3D]"
+                      >
+                        <Trash2 className="h-3 w-3 mr-1" />
+                        Delete All
+                      </Button>
+                    </div>
+                    <ul className="space-y-2 max-h-40 overflow-y-auto">
+                      {downloadedFiles.map((file, index) => (
+                        <li
+                          key={index}
+                          className="flex justify-between items-center p-2 bg-gray-50 dark:bg-shadeA rounded text-sm"
+                        >
+                          <span className="text-black dark:text-white truncate flex-1">
+                            {file.name}
+                          </span>
+                          <Button
+                            onClick={() => handleDeleteDownloadedFile(file.name)}
+                            variant="ghost"
+                            size="sm"
+                            className="ml-2 text-red-500 hover:text-red-700 dark:hover:text-red-400"
+                          >
+                            <Trash2 className="h-3 w-3" />
+                          </Button>
+                        </li>
+                      ))}
+                    </ul>
+                  </div>
+                )}
+
+                {/* Ingest Downloaded Data Section */}
+                {downloadedFiles.length > 0 && (
+                  <div className="border-t border-gray-300 dark:border-[#3D3D3D] pt-4 mt-4">
+                    <h3 className="text-sm font-medium mb-2 text-black dark:text-white">
+                      Ingest Documents into Knowledge Graph
+                    </h3>
+                    <p className="text-xs text-gray-500 dark:text-gray-400 mb-3">
+                      Process downloaded files and add them to the knowledge graph
+                    </p>
+                    <Button
+                      onClick={() => handleRunIngest("downloaded")}
+                      disabled={isIngesting || isProcessingFiles}
+                      className="gradient text-white w-full"
+                    >
+                      {isIngesting ? (
+                        <>
+                          <Loader2 className="h-4 w-4 mr-2 animate-spin" />
+                          Ingesting...
+                        </>
+                      ) : isProcessingFiles ? (
+                        <>
+                          <Loader2 className="h-4 w-4 mr-2 animate-spin" />
+                          Processing files...
+                        </>
+                      ) : (
+                        <>
+                          <Database className="h-4 w-4 mr-2" />
+                          Ingest Documents into {ingestGraphName}
+                        </>
+                      )}
+                    </Button>
+                  </div>
+                )}
+              </div>
+            </TabsContent>
+
+            {/* Amazon BDA Configuration Tab */}
+            <TabsContent value="AmazonBDA" className="space-y-4">
+              <div className="space-y-4">
+                <p className="text-sm font-medium text-gray-500 dark:text-gray-400 mb-3">
+                  Process multimodal documents stored in S3 with Amazon Bedrock Data
+                  Automation and ingest them into your knowledge graph.
+                </p>
+
+                {/* Common fields */}
+                <div>
+                  <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                    AWS Access Key
+                  </label>
+                  <Input
+                    type="text"
+                    value={awsAccessKey}
+                    onChange={(e) => setAwsAccessKey(e.target.value)}
+                    placeholder="Enter AWS access key"
+                    className="dark:border-[#3D3D3D] dark:bg-shadeA"
+                    disabled={isIngesting}
+                  />
+                </div>
+
+                <div>
+                  <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                    AWS Secret Key
+                  </label>
+                  <Input
+                    type="password"
+                    value={awsSecretKey}
+                    onChange={(e) => setAwsSecretKey(e.target.value)}
+                    placeholder="Enter AWS secret key"
+                    className="dark:border-[#3D3D3D] dark:bg-shadeA"
+                    disabled={isIngesting}
+                  />
+                </div>
+
+                <div>
+                  <div className="flex items-center justify-between mb-2">
+                    <label className="block text-sm font-medium text-black dark:text-white">
+                      Input Bucket
+                    </label>
+                    <label className="flex items-center gap-2 text-sm text-gray-600 dark:text-gray-400 cursor-pointer">
+                      <input
+                        type="checkbox"
+                        checked={skipBDAProcessing}
+                        onChange={(e) => setSkipBDAProcessing(e.target.checked)}
+                        disabled={isIngesting}
+                        className="h-4 w-4 rounded border-gray-300 dark:border-gray-600"
+                      />
+                      <span>Skip BDA (ingest existing BDA output bucket directly)</span>
+                    </label>
+                  </div>
+                  <Input
+                    type="text"
+                    value={inputBucket}
+                    onChange={(e) => setInputBucket(e.target.value)}
+                    placeholder="Enter input bucket name"
+                    className="dark:border-[#3D3D3D] dark:bg-shadeA"
+                    disabled={isIngesting || skipBDAProcessing}
+                  />
+                </div>
+
+                <div>
+                  <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                    Output Bucket
+                  </label>
+                  <Input
+                    type="text"
+                    value={outputBucket}
+                    onChange={(e) => setOutputBucket(e.target.value)}
+                    placeholder="Enter output bucket name"
+                    className="dark:border-[#3D3D3D] dark:bg-shadeA"
+                    disabled={isIngesting}
+                  />
+                </div>
+
+                <div>
+                  <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                    Region Name
+                  </label>
+                  <Input
+                    type="text"
+                    value={regionName}
+                    onChange={(e) => setRegionName(e.target.value)}
+                    placeholder="e.g., us-east-1"
+                    className="dark:border-[#3D3D3D] dark:bg-shadeA"
+                    disabled={isIngesting}
+                  />
+                </div>
+
+                {ingestGraphName && (
+                  <p className="text-xs text-gray-500 dark:text-gray-400 mb-2">
+                    Processing destination: Input bucket ({inputBucket || "not specified"}
+                    ) → Output bucket ({outputBucket || "not specified"}) → Knowledge
+                    graph ({ingestGraphName})
+                  </p>
+                )}
+
+                {/* Ingest S3 Files with Amazon BDA Section */}
+                <div className="border-t border-gray-300 dark:border-[#3D3D3D] pt-4 mt-4">
+                  <Button
+                    onClick={handleAmazonBDAIngest}
+                    disabled={isIngesting}
+                    className="gradient text-white w-full"
+                  >
+                    {isIngesting ? (
+                      <>
+                        <Loader2 className="h-4 w-4 mr-2 animate-spin" />
+                        Ingesting...
+                      </>
+                    ) : (
+                      <>
+                        <Database className="h-4 w-4 mr-2" />
+                        Ingest from S3 Bucket into {ingestGraphName}
+                      </>
+                    )}
+                  </Button>
+                  {ingestMessage && (
+                    <div
+                      className={`p-3 rounded-lg text-sm mt-3 ${
+                        ingestMessage.includes("✅")
+                          ? "bg-green-50 dark:bg-green-900/20 text-green-700 dark:text-green-300"
+                          : ingestMessage.includes("❌")
+                          ? "bg-red-50 dark:bg-red-900/20 text-red-700 dark:text-red-300"
+                          : "bg-blue-50 dark:bg-blue-900/20 text-blue-700 dark:text-blue-300"
+                      }`}
+                    >
+                      {ingestMessage}
+                    </div>
+                  )}
+                </div>
+              </div>
+            </TabsContent>
+          </Tabs>
+        </div>
+      </div>
+      {confirmDialog}
+    </div>
+  );
+};
+
+export default IngestGraph;
+
diff --git a/graphrag-ui/src/pages/setup/KGAdmin.tsx b/graphrag-ui/src/pages/setup/KGAdmin.tsx
new file mode 100644
index 0000000..0579376
--- /dev/null
+++ b/graphrag-ui/src/pages/setup/KGAdmin.tsx
@@ -0,0 +1,690 @@
+import React, { useState, useEffect, useRef } from "react";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Database, Loader2, RefreshCw, Upload } from "lucide-react";
+import { pauseIdleTimer, resumeIdleTimer } from "@/hooks/useIdleTimeout";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from "@/components/ui/dialog";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import { useConfirm } from "@/hooks/useConfirm";
+import { useNavigate } from "react-router-dom";
+import IngestGraph from "./IngestGraph";
+
+const KGAdmin = () => {
+  const [confirm, confirmDialog, isConfirmDialogOpen] = useConfirm();
+  const navigate = useNavigate();
+  const [availableGraphs, setAvailableGraphs] = useState<string[]>([]);
+  
+  // Dialog states
+  const [initializeDialogOpen, setInitializeDialogOpen] = useState(false);
+  const [refreshDialogOpen, setRefreshDialogOpen] = useState(false);
+  const [ingestDialogOpen, setIngestDialogOpen] = useState(false);
+
+  // Reset states when dialogs close
+  const handleInitializeDialogChange = (open: boolean) => {
+    if (!open && isConfirmDialogOpen) {
+      return;
+    }
+    setInitializeDialogOpen(open);
+    if (!open) {
+      setGraphName("");
+      setStatusMessage("");
+      setStatusType("");
+    }
+  };
+
+  const handleRefreshDialogChange = (open: boolean) => {
+    if (!open && isConfirmDialogOpen) {
+      return;
+    }
+    setRefreshDialogOpen(open);
+    if (!open) {
+      setRefreshMessage("");
+      setPollingActive(false);
+    }
+  };
+
+  // Initialize state
+  const [graphName, setGraphName] = useState("");
+  const [isInitializing, setIsInitializing] = useState(false);
+  const [statusMessage, setStatusMessage] = useState("");
+  const [statusType, setStatusType] = useState<"success" | "error" | "">("");
+
+  // Refresh state
+  const [refreshGraphName, setRefreshGraphName] = useState("");
+  const [isRefreshing, setIsRefreshing] = useState(false);
+  const [refreshMessage, setRefreshMessage] = useState("");
+  const [isRebuildRunning, setIsRebuildRunning] = useState(false);
+  const isRebuildRunningRef = useRef(false);
+  const [isCheckingStatus, setIsCheckingStatus] = useState(false);
+  const [pollingActive, setPollingActive] = useState(false);
+
+  // Load available graphs
+  useEffect(() => {
+    const store = JSON.parse(sessionStorage.getItem("site") || "{}");
+    if (store.graphs && Array.isArray(store.graphs)) {
+      setAvailableGraphs(store.graphs);
+      if (store.graphs.length > 0 && !refreshGraphName) {
+        setRefreshGraphName(store.graphs[0]);
+      }
+    }
+  }, []);
+
+  // Initialize Graph
+  const handleInitializeGraph = async () => {
+    if (!graphName.trim()) {
+      setStatusMessage("Please enter a graph name");
+      setStatusType("error");
+      return;
+    }
+
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(graphName)) {
+      setStatusMessage("Invalid graph name. Must start with a letter or underscore, followed by letters, digits, or underscores.");
+      setStatusType("error");
+      return;
+    }
+
+    setIsInitializing(true);
+    setStatusMessage("Creating graph and initializing GraphRAG schema...");
+    setStatusType("");
+
+    try {
+      const creds = sessionStorage.getItem("creds");
+      if (!creds) {
+        throw new Error("Not authenticated. Please login first.");
+      }
+
+      setStatusMessage("Step 1/2: Creating graph...");
+      const createResponse = await fetch(`/ui/${graphName}/create_graph`, {
+        method: "POST",
+        headers: { Authorization: `Basic ${creds}` },
+      });
+
+      const createData = await createResponse.json();
+
+      if (!createResponse.ok) {
+        const detail = createData.detail;
+        const msg = typeof detail === "string"
+          ? detail
+          : Array.isArray(detail)
+            ? detail.map((d: any) => d.msg || JSON.stringify(d)).join("; ")
+            : createData.message || `Failed to create graph: ${createResponse.statusText}`;
+        throw new Error(msg);
+      }
+
+      if (createData.status !== "success") {
+        if (createData.message && createData.message.includes("already exists")) {
+          const shouldInitialize = await confirm(
+            `Graph "${graphName}" already exists. Do you want to initialize it with GraphRAG schema?`
+          );
+          if (!shouldInitialize) {
+            setStatusMessage("Operation cancelled by user.");
+            setStatusType("error");
+            setIsInitializing(false);
+            return;
+          }
+        } else {
+          throw new Error(
+            createData.message || `Failed to create graph: ${createData.details}`
+          );
+        }
+      }
+
+      setStatusMessage("Step 2/2: Initializing GraphRAG schema...");
+      const initResponse = await fetch(`/ui/${graphName}/initialize_graph`, {
+        method: "POST",
+        headers: { Authorization: `Basic ${creds}` },
+      });
+
+      const initData = await initResponse.json();
+
+      if (!initResponse.ok) {
+        throw new Error(
+          initData.detail || `Failed to initialize graph: ${initResponse.statusText}`
+        );
+      }
+
+      if (initData.status !== "success") {
+        setStatusMessage(
+          initData.message || `Failed to initialize graph: ${initData.details}`
+        );
+        setStatusType("error");
+        setIsInitializing(false);
+        return;
+      }
+
+      setStatusMessage(
+        `✅ Graph "${graphName}" created and initialized successfully! You can now close this dialog.`
+      );
+      setStatusType("success");
+
+      const newGraph = graphName;
+      setAvailableGraphs(prev => {
+        if (!prev.includes(newGraph)) {
+          const updated = [...prev, newGraph];
+          const store = JSON.parse(sessionStorage.getItem("site") || "{}");
+          store.graphs = updated;
+          sessionStorage.setItem("site", JSON.stringify(store));
+          return updated;
+        }
+        return prev;
+      });
+
+      setRefreshGraphName(graphName);
+      setGraphName("");
+    } catch (error: any) {
+      console.error("Error creating graph:", error);
+      setStatusMessage(`❌ Error: ${error.message}`);
+      setStatusType("error");
+    } finally {
+      setIsInitializing(false);
+    }
+  };
+
+  // Check rebuild status
+  const checkRebuildStatus = async (
+    graphName: string,
+    showLoadingMessage: boolean = false
+  ) => {
+    if (!graphName) return;
+
+    setIsCheckingStatus(true);
+    if (showLoadingMessage) {
+      setRefreshMessage("Checking rebuild status...");
+    }
+
+    try {
+      const creds = sessionStorage.getItem("creds");
+      const statusResponse = await fetch(`/ui/${graphName}/rebuild_status`, {
+        method: "GET",
+        headers: { Authorization: `Basic ${creds}` },
+      });
+
+      if (statusResponse.ok) {
+        const statusData = await statusResponse.json();
+        const wasRunning = isRebuildRunningRef.current;
+        const isCurrentlyRunning = statusData.is_running || false;
+
+        setIsRebuildRunning(isCurrentlyRunning);
+        isRebuildRunningRef.current = isCurrentlyRunning;
+
+        if (isCurrentlyRunning) {
+          setPollingActive(true);
+          const startTime = statusData.started_at
+            ? new Date(statusData.started_at * 1000).toLocaleString()
+            : "unknown time";
+          setRefreshMessage(
+            `⚠️ A rebuild is already in progress for "${graphName}" (started at ${startTime}). Please wait for it to complete.`
+          );
+        } else if (wasRunning && statusData.status === "completed") {
+          setRefreshMessage(`✅ Rebuild completed successfully for "${graphName}".`);
+          setPollingActive(false);
+        } else if (statusData.status === "failed") {
+          setRefreshMessage(`❌ Previous rebuild failed: ${statusData.error || "Unknown error"}`);
+          setPollingActive(false);
+        } else if (statusData.status === "error") {
+          setRefreshMessage(`❌ Failed to check rebuild status: ${statusData.error || "Unknown error"}`);
+          setPollingActive(false);
+        } else if (statusData.status === "unknown") {
+          setRefreshMessage(`⚠️ ECC service returned unknown status. It may be unavailable.`);
+          setPollingActive(false);
+        } else {
+          setRefreshMessage("");
+        }
+      } else {
+        setRefreshMessage(`❌ Failed to check rebuild status (HTTP ${statusResponse.status}).`);
+      }
+    } catch (error: any) {
+      console.error("Error checking rebuild status:", error);
+      if (showLoadingMessage) {
+        setRefreshMessage(`❌ Unable to reach ECC service: ${error.message || "Connection failed"}`);
+      }
+    } finally {
+      setIsCheckingStatus(false);
+    }
+  };
+
+  // Refresh Graph
+  const handleRefreshGraph = async () => {
+    if (!refreshGraphName) {
+      setRefreshMessage("Please select a graph");
+      return;
+    }
+
+    if (isRebuildRunning) {
+      setRefreshMessage(
+        `⚠️ A rebuild is already in progress. Please wait for it to complete.`
+      );
+      return;
+    }
+
+    setIsRefreshing(true);
+
+    const shouldRefresh = await confirm(
+      `Are you sure you want to refresh the knowledge graph "${refreshGraphName}"? This will rebuild the graph content.`
+    );
+    if (!shouldRefresh) {
+      setRefreshMessage("Operation cancelled by user.");
+      setIsRefreshing(false);
+      return;
+    }
+
+    setRefreshMessage("Verifying rebuild status...");
+
+    try {
+      const creds = sessionStorage.getItem("creds");
+
+      // Final status check to prevent race conditions
+      const statusCheckResponse = await fetch(`/ui/${refreshGraphName}/rebuild_status`, {
+        method: "GET",
+        headers: { Authorization: `Basic ${creds}` },
+      });
+
+      if (statusCheckResponse.ok) {
+        const statusData = await statusCheckResponse.json();
+        if (statusData.is_running) {
+          setRefreshMessage(`⚠️ A rebuild is already in progress for "${refreshGraphName}". Please wait for it to complete.`);
+          setIsRebuildRunning(true);
+          isRebuildRunningRef.current = true;
+          setIsRefreshing(false);
+          return;
+        }
+      }
+
+      setRefreshMessage("Submitting rebuild request...");
+
+      const response = await fetch(`/ui/${refreshGraphName}/rebuild_graph`, {
+        method: "POST",
+        headers: { Authorization: `Basic ${creds}` },
+      });
+
+      if (!response.ok) {
+        const errorData = await response.json();
+        if (response.status === 409) {
+          setRefreshMessage(`⚠️ ${errorData.detail || errorData.message}`);
+          setIsRefreshing(false);
+          return;
+        }
+        throw new Error(
+          errorData.detail || `Failed to refresh graph: ${response.statusText}`
+        );
+      }
+
+      const data = await response.json();
+      console.log("Refresh response:", data);
+
+      setRefreshMessage(
+        `✅ Refresh submitted successfully! The knowledge graph "${refreshGraphName}" is being rebuilt.`
+      );
+      setIsRebuildRunning(true);
+      isRebuildRunningRef.current = true;
+      setPollingActive(true);
+    } catch (error: any) {
+      console.error("Error refreshing graph:", error);
+      setRefreshMessage(`❌ Error: ${error.message}`);
+    } finally {
+      setIsRefreshing(false);
+    }
+  };
+
+  // Initial status check when dialog opens
+  useEffect(() => {
+    if (refreshDialogOpen && refreshGraphName) {
+      checkRebuildStatus(refreshGraphName, true);
+    }
+  }, [refreshDialogOpen, refreshGraphName]);
+
+  // Poll status only while a rebuild is actively running
+  useEffect(() => {
+    if (!pollingActive || !refreshDialogOpen || !refreshGraphName) return;
+
+    pauseIdleTimer();
+    const intervalId = setInterval(() => {
+      checkRebuildStatus(refreshGraphName, false);
+    }, 5000);
+
+    return () => {
+      clearInterval(intervalId);
+      resumeIdleTimer();
+    };
+  }, [pollingActive, refreshDialogOpen, refreshGraphName]);
+
+  return (
+    <div className="p-8">
+      <div className="max-w-7xl mx-auto">
+        <div className="mb-8">
+          <h1 className="text-2xl font-bold text-black dark:text-white mb-2">
+            Knowledge Graph Setup
+          </h1>
+          <p className="text-sm text-gray-600 dark:text-[#D9D9D9]">
+            Configure and manage your knowledge graphs
+          </p>
+        </div>
+
+        {/* Card Grid */}
+        <div className="grid grid-cols-1 lg:grid-cols-3 gap-6">
+          {/* Initialize Card */}
+          <div className="border border-gray-300 dark:border-[#3D3D3D] rounded-lg p-6 bg-white dark:bg-shadeA flex flex-col h-full">
+            <div className="mb-4">
+              <div className="w-12 h-12 rounded-full bg-tigerOrange/10 flex items-center justify-center mb-4">
+                <Database className="h-6 w-6 text-tigerOrange" />
+              </div>
+              <h2 className="text-lg font-semibold mb-2 text-black dark:text-white">
+                Initialize Knowledge Graph
+              </h2>
+              <p className="text-sm text-gray-600 dark:text-[#D9D9D9] mb-4">
+                Create the knowledge graph schema and queries for future document ingestion.
+              </p>
+            </div>
+            <div className="mt-auto pt-4 border-t border-gray-300 dark:border-[#3D3D3D]">
+              <Button
+                onClick={() => setInitializeDialogOpen(true)}
+                className="gradient w-full text-white"
+              >
+                <Database className="h-4 w-4 mr-2" />
+                Initialize Graph
+              </Button>
+            </div>
+          </div>
+
+          {/* Ingest Card */}
+          <div className="border border-gray-300 dark:border-[#3D3D3D] rounded-lg p-6 bg-white dark:bg-shadeA flex flex-col h-full">
+            <div className="mb-4">
+              <div className="w-12 h-12 rounded-full bg-tigerOrange/10 flex items-center justify-center mb-4">
+                <Upload className="h-6 w-6 text-tigerOrange" />
+              </div>
+              <h2 className="text-lg font-semibold mb-2 text-black dark:text-white">
+                Ingest to Knowledge Graph
+              </h2>
+              <p className="text-sm text-gray-600 dark:text-[#D9D9D9] mb-4">
+                Upload and ingest documents into your knowledge graph for future content processing.
+              </p>
+            </div>
+            <div className="mt-auto pt-4 border-t border-gray-300 dark:border-[#3D3D3D]">
+              <Button
+                onClick={() => setIngestDialogOpen(true)}
+                className="gradient w-full text-white"
+              >
+                <Upload className="h-4 w-4 mr-2" />
+                Ingest Document
+              </Button>
+            </div>
+          </div>
+
+          {/* Refresh Card */}
+          <div className="border border-gray-300 dark:border-[#3D3D3D] rounded-lg p-6 bg-white dark:bg-shadeA flex flex-col h-full">
+            <div className="mb-4">
+              <div className="w-12 h-12 rounded-full bg-tigerOrange/10 flex items-center justify-center mb-4">
+                <RefreshCw className="h-6 w-6 text-tigerOrange" />
+              </div>
+              <h2 className="text-lg font-semibold mb-2 text-black dark:text-white">
+                Refresh Knowledge Graph
+              </h2>
+              <p className="text-sm text-gray-600 dark:text-[#D9D9D9] mb-4">
+                Process new documents in your knowledge graph to refresh its content.
+              </p>
+            </div>
+            <div className="mt-auto pt-4 border-t border-gray-300 dark:border-[#3D3D3D]">
+              <Button
+                onClick={() => setRefreshDialogOpen(true)}
+                className="gradient w-full text-white"
+              >
+                <RefreshCw className="h-4 w-4 mr-2" />
+                Refresh Graph
+              </Button>
+            </div>
+          </div>
+        </div>
+
+        {/* Initialize Dialog */}
+        <Dialog open={initializeDialogOpen} onOpenChange={handleInitializeDialogChange}>
+          <DialogContent
+            className="sm:max-w-[500px] bg-white dark:bg-background border-gray-300 dark:border-[#3D3D3D]"
+            onInteractOutside={(e) => e.preventDefault()}
+          >
+            <DialogHeader>
+              <DialogTitle className="text-black dark:text-white">Initialize Knowledge Graph</DialogTitle>
+              <DialogDescription className="text-gray-600 dark:text-[#D9D9D9]">
+                Enter the name of your knowledge graph. The system will create it if necessary and initialize it with the GraphRAG schema.
+              </DialogDescription>
+            </DialogHeader>
+
+            <div className="py-4">
+              <div className="mb-4">
+                <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                  Knowledge Graph Name
+                </label>
+                <Input
+                  placeholder="e.g., MyKnowledgeGraph"
+                  value={graphName}
+                  onChange={(e) => setGraphName(e.target.value)}
+                  disabled={isInitializing}
+                  className="dark:border-[#3D3D3D] dark:bg-shadeA"
+                  onKeyDown={(e) => {
+                    if (e.key === "Enter" && !isInitializing) {
+                      handleInitializeGraph();
+                    }
+                  }}
+                />
+              </div>
+
+              {statusMessage && (
+                <div
+                  className={`p-3 rounded-lg text-sm ${
+                    statusType === "success"
+                      ? "bg-green-50 dark:bg-green-900/20 text-green-700 dark:text-green-300"
+                      : statusType === "error"
+                      ? "bg-red-50 dark:bg-red-900/20 text-red-700 dark:text-red-300"
+                      : "bg-blue-50 dark:bg-blue-900/20 text-blue-700 dark:text-blue-300"
+                  }`}
+                >
+                  {statusMessage}
+                </div>
+              )}
+            </div>
+
+            <DialogFooter>
+              {statusType === "success" ? (
+                <Button
+                  className="gradient text-white w-full"
+                  onClick={() => {
+                    setInitializeDialogOpen(false);
+                    setGraphName("");
+                    setStatusMessage("");
+                    setStatusType("");
+                  }}
+                >
+                  Done
+                </Button>
+              ) : (
+                <>
+                  <Button
+                    variant="outline"
+                    onClick={() => handleInitializeDialogChange(false)}
+                    disabled={isInitializing}
+                    className="dark:border-[#3D3D3D]"
+                  >
+                    Cancel
+                  </Button>
+                  <Button
+                    onClick={handleInitializeGraph}
+                    disabled={isInitializing || !graphName.trim()}
+                    className="gradient text-white"
+                  >
+                    {isInitializing ? (
+                      <>
+                        <Loader2 className="h-4 w-4 mr-2 animate-spin" />
+                        Creating...
+                      </>
+                    ) : (
+                      <>
+                        <Database className="h-4 w-4 mr-2" />
+                        Create & Initialize
+                      </>
+                    )}
+                  </Button>
+                </>
+              )}
+            </DialogFooter>
+          </DialogContent>
+        </Dialog>
+
+        {/* Ingest Dialog */}
+        <Dialog
+          open={ingestDialogOpen}
+          onOpenChange={(open) => {
+            if (!open && isConfirmDialogOpen) {
+              return;
+            }
+            setIngestDialogOpen(open);
+          }}
+        >
+          <DialogContent
+            className="sm:max-w-[700px] bg-white dark:bg-background border-gray-300 dark:border-[#3D3D3D] max-h-[80vh] overflow-y-auto"
+            onInteractOutside={(e) => e.preventDefault()}
+          >
+            <DialogHeader>
+              <DialogTitle className="text-black dark:text-white">Document Ingestion for Knowledge Graph</DialogTitle>
+              <DialogDescription className="text-gray-600 dark:text-[#D9D9D9]">
+                Upload files locally, download from cloud storage, or configure Amazon Bedrock Data Automation for document ingestion
+              </DialogDescription>
+            </DialogHeader>
+            <IngestGraph isModal={true} />
+            <DialogFooter>
+              <Button
+                variant="outline"
+                onClick={() => setIngestDialogOpen(false)}
+                className="dark:border-[#3D3D3D]"
+              >
+                Close
+              </Button>
+            </DialogFooter>
+          </DialogContent>
+        </Dialog>
+
+        {/* Refresh Dialog */}
+        <Dialog open={refreshDialogOpen} onOpenChange={handleRefreshDialogChange}>
+          <DialogContent
+            className="sm:max-w-[500px] bg-white dark:bg-background border-gray-300 dark:border-[#3D3D3D]"
+            onInteractOutside={(e) => e.preventDefault()}
+          >
+            <DialogHeader>
+              <DialogTitle className="text-black dark:text-white">Refresh Knowledge Graph</DialogTitle>
+              <DialogDescription className="text-gray-600 dark:text-[#D9D9D9]">
+                Rebuild the graph content and rerun community detection for your knowledge graph
+              </DialogDescription>
+            </DialogHeader>
+
+            <div className="py-4 space-y-4">
+              <div>
+                <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                  Select Graph to Refresh
+                </label>
+                <Select
+                  value={refreshGraphName}
+                  onValueChange={setRefreshGraphName}
+                  disabled={isRefreshing || isRebuildRunning || isCheckingStatus}
+                >
+                  <SelectTrigger
+                    className="dark:border-[#3D3D3D] dark:bg-shadeA"
+                    disabled={isRefreshing || isRebuildRunning || isCheckingStatus}
+                  >
+                    <SelectValue placeholder="Select a graph" />
+                  </SelectTrigger>
+                  <SelectContent>
+                    {availableGraphs.length > 0 ? (
+                      availableGraphs.map((graph) => (
+                        <SelectItem key={graph} value={graph}>
+                          {graph}
+                        </SelectItem>
+                      ))
+                    ) : (
+                      <SelectItem value="no-graphs" disabled>
+                        No graphs available
+                      </SelectItem>
+                    )}
+                  </SelectContent>
+                </Select>
+              </div>
+
+              <div className="bg-yellow-50 dark:bg-yellow-900/20 border border-yellow-200 dark:border-yellow-800 rounded-lg p-4">
+                <p className="text-sm text-yellow-800 dark:text-yellow-200 font-medium">
+                  ⚠️ Warning
+                </p>
+                <p className="text-sm text-yellow-700 dark:text-yellow-300 mt-1">
+                  This operation will process new documents and rerun community detection that will interrupt related queries.
+                  Please confirm to proceed.
+                </p>
+              </div>
+
+              {refreshMessage && (
+                <div className={`p-3 rounded-lg text-sm ${
+                  refreshMessage.includes("✅")
+                    ? "bg-green-50 dark:bg-green-900/20 text-green-700 dark:text-green-300"
+                    : refreshMessage.includes("❌")
+                    ? "bg-red-50 dark:bg-red-900/20 text-red-700 dark:text-red-300"
+                    : "bg-blue-50 dark:bg-blue-900/20 text-blue-700 dark:text-blue-300"
+                }`}>
+                  {refreshMessage}
+                </div>
+              )}
+            </div>
+
+            <DialogFooter>
+              <Button
+                variant="outline"
+                onClick={() => handleRefreshDialogChange(false)}
+                disabled={isRefreshing}
+                className="dark:border-[#3D3D3D]"
+              >
+                Close
+              </Button>
+              <Button
+                onClick={handleRefreshGraph}
+                disabled={isRefreshing || !refreshGraphName || isRebuildRunning || isCheckingStatus}
+                className="gradient text-white"
+              >
+                {isRefreshing ? (
+                  <>
+                    <Loader2 className="h-4 w-4 mr-2 animate-spin" />
+                    Submitting...
+                  </>
+                ) : isRebuildRunning ? (
+                  <>
+                    <Loader2 className="h-4 w-4 mr-2 animate-spin" />
+                    Rebuild In Progress...
+                  </>
+                ) : isCheckingStatus ? (
+                  <>
+                    <Loader2 className="h-4 w-4 mr-2 animate-spin" />
+                    Checking Status...
+                  </>
+                ) : (
+                  <>
+                    <RefreshCw className="h-4 w-4 mr-2" />
+                    Confirm & Refresh
+                  </>
+                )}
+              </Button>
+            </DialogFooter>
+          </DialogContent>
+        </Dialog>
+      </div>
+      {confirmDialog}
+    </div>
+  );
+};
+
+export default KGAdmin;
diff --git a/graphrag-ui/src/pages/setup/LLMConfig.tsx b/graphrag-ui/src/pages/setup/LLMConfig.tsx
new file mode 100644
index 0000000..aa5596f
--- /dev/null
+++ b/graphrag-ui/src/pages/setup/LLMConfig.tsx
@@ -0,0 +1,1612 @@
+import React, { useState, useEffect } from "react";
+import { Server, CheckCircle2, Save, Loader2 } from "lucide-react";
+import { Input } from "@/components/ui/input";
+import { Button } from "@/components/ui/button";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import ConfigScopeToggle from "@/components/ConfigScopeToggle";
+
+// Type definitions for provider fields
+interface FieldConfig {
+  key: string;
+  label: string;
+  type: string;
+  required?: boolean;
+  placeholder?: string;
+}
+
+interface ProviderConfig {
+  authFields: FieldConfig[];
+  configFields: FieldConfig[];
+  note?: string;
+}
+
+// Provider-specific field configuration
+const PROVIDER_FIELDS: Record<string, ProviderConfig> = {
+  openai: {
+    authFields: [
+      { key: "OPENAI_API_KEY", label: "API Key", type: "password", required: true }
+    ],
+    configFields: []
+  },
+  azure: {
+    authFields: [
+      { key: "AZURE_OPENAI_API_KEY", label: "Azure OpenAI API Key", type: "password", required: true },
+      { key: "AZURE_OPENAI_ENDPOINT", label: "Azure Endpoint", type: "text", required: true, placeholder: "https://your-resource.openai.azure.com/" },
+      { key: "OPENAI_API_VERSION", label: "API Version", type: "text", required: true, placeholder: "2024-02-15-preview" }
+    ],
+    configFields: [
+      { key: "azure_deployment", label: "Azure Deployment Name", type: "text", required: true, placeholder: "gpt-4" }
+    ]
+  },
+  genai: {
+    authFields: [
+      { key: "GOOGLE_API_KEY", label: "Google API Key", type: "password", required: true }
+    ],
+    configFields: []
+  },
+  vertexai: {
+    authFields: [],
+    configFields: [
+      { key: "project", label: "GCP Project ID (Optional)", type: "text", placeholder: "my-project-id" },
+      { key: "location", label: "Location (Optional)", type: "text", placeholder: "us-central1" }
+    ],
+    note: "VertexAI uses service account credentials from GOOGLE_APPLICATION_CREDENTIALS environment variable"
+  },
+  bedrock: {
+    authFields: [
+      { key: "AWS_ACCESS_KEY_ID", label: "AWS Access Key ID", type: "password", required: true },
+      { key: "AWS_SECRET_ACCESS_KEY", label: "AWS Secret Access Key", type: "password", required: true }
+    ],
+    configFields: [
+      { key: "region_name", label: "AWS Region", type: "text", required: true, placeholder: "us-east-1" }
+    ]
+  },
+  groq: {
+    authFields: [
+      { key: "GROQ_API_KEY", label: "Groq API Key", type: "password", required: true }
+    ],
+    configFields: []
+  },
+  ollama: {
+    authFields: [],
+    configFields: [
+      { key: "base_url", label: "Ollama Base URL", type: "text", required: true, placeholder: "http://localhost:11434" }
+    ]
+  },
+  sagemaker: {
+    authFields: [
+      { key: "AWS_ACCESS_KEY_ID", label: "AWS Access Key ID", type: "password", required: true },
+      { key: "AWS_SECRET_ACCESS_KEY", label: "AWS Secret Access Key", type: "password", required: true }
+    ],
+    configFields: [
+      { key: "region_name", label: "AWS Region", type: "text", required: true, placeholder: "us-east-1" },
+      { key: "endpoint_name", label: "SageMaker Endpoint Name", type: "text", required: true }
+    ]
+  },
+  huggingface: {
+    authFields: [
+      { key: "HUGGINGFACEHUB_API_TOKEN", label: "HuggingFace API Token", type: "password", required: true }
+    ],
+    configFields: [
+      { key: "endpoint_url", label: "Endpoint URL (Optional)", type: "text", placeholder: "https://api-inference.huggingface.co/models/..." }
+    ]
+  },
+  watsonx: {
+    authFields: [
+      { key: "WATSONX_API_KEY", label: "IBM WatsonX API Key", type: "password", required: true },
+      { key: "WATSONX_URL", label: "WatsonX URL", type: "text", required: true, placeholder: "https://us-south.ml.cloud.ibm.com" },
+      { key: "WATSONX_PROJECT_ID", label: "Project ID", type: "text", required: true }
+    ],
+    configFields: []
+  }
+};
+
+const LLMConfig = () => {
+  const [selectedGraph, setSelectedGraph] = useState(sessionStorage.getItem("selectedGraph") || "");
+  const [availableGraphs, setAvailableGraphs] = useState<string[]>([]);
+  const [useMultipleProviders, setUseMultipleProviders] = useState(false);
+  const [llmConfigAccess, setLlmConfigAccess] = useState<"full" | "chatbot_only">("full");
+  const [isLoading, setIsLoading] = useState(true);
+  const [isSaving, setIsSaving] = useState(false);
+  const [isTesting, setIsTesting] = useState(false);
+  const [message, setMessage] = useState("");
+  const [messageType, setMessageType] = useState<"success" | "error" | "">("");
+  const [testResults, setTestResults] = useState<any>(null);
+  const [connectionTested, setConnectionTested] = useState(false);
+  
+  // Single provider state
+  const [singleProvider, setSingleProvider] = useState("openai");
+  const [singleConfig, setSingleConfig] = useState<Record<string, string>>({});
+  const [singleDefaultModel, setSingleDefaultModel] = useState("");
+  const [singleEmbeddingModel, setSingleEmbeddingModel] = useState("");
+  const [multimodalModel, setMultimodalModel] = useState("");
+
+  // Multi-provider state
+  const [completionProvider, setCompletionProvider] = useState("openai");
+  const [completionConfig, setCompletionConfig] = useState<Record<string, string>>({});
+  const [completionDefaultModel, setCompletionDefaultModel] = useState("");
+  
+  const [embeddingProvider, setEmbeddingProvider] = useState("openai");
+  const [embeddingConfig, setEmbeddingConfig] = useState<Record<string, string>>({});
+  const [embeddingModel, setEmbeddingModel] = useState("");
+  
+  const [multimodalProvider, setMultimodalProvider] = useState("openai");
+  const [multimodalConfig, setMultimodalConfig] = useState<Record<string, string>>({});
+  const [multimodalModelName, setMultimodalModelName] = useState("");
+  const isChatbotOnlyMode = llmConfigAccess === "chatbot_only";
+
+  // Per-graph chatbot config state (chatbot_only mode)
+  const [useCustomChatbot, setUseCustomChatbot] = useState(false);
+  const [chatbotProvider, setChatbotProvider] = useState("openai");
+  const [chatbotProviderConfig, setChatbotProviderConfig] = useState<Record<string, string>>({});
+  const [chatbotModelName, setChatbotModelName] = useState("");
+  const [chatbotTemperature, setChatbotTemperature] = useState("0");
+  const [globalChatInfo, setGlobalChatInfo] = useState({ llm_service: "", llm_model: "" });
+
+  // Superadmin scope: "global" edits global config, "graph" edits per-graph overrides
+  const [configScope, setConfigScope] = useState<"global" | "graph">("global");
+  const [graphOverrides, setGraphOverrides] = useState<Record<string, any>>({});
+
+
+  // Load available graphs and config on mount
+  useEffect(() => {
+    const site = JSON.parse(sessionStorage.getItem("site") || "{}");
+    setAvailableGraphs(site.graphs || []);
+    fetchConfig();
+  }, []);
+
+  const fetchConfig = async (scope?: "global" | "graph", graphname?: string) => {
+    setIsLoading(true);
+    const effectiveScope = scope ?? configScope;
+    const effectiveGraph = graphname ?? selectedGraph;
+    try {
+      const creds = sessionStorage.getItem("creds");
+      const params = new URLSearchParams();
+      if (effectiveGraph) params.set("graphname", effectiveGraph);
+      if (effectiveScope === "graph") params.set("scope", "graph");
+      const queryString = params.toString() ? `?${params.toString()}` : "";
+      const response = await fetch(`/ui/config${queryString}`, {
+        headers: { Authorization: `Basic ${creds}` },
+      });
+
+      if (!response.ok) {
+        throw new Error("Failed to fetch configuration");
+      }
+
+      const data = await response.json();
+      const llmConfig = data.llm_config;
+      setLlmConfigAccess(data.llm_config_access === "chatbot_only" ? "chatbot_only" : "full");
+
+      // Parse per-graph chatbot config (chatbot_only mode)
+      if (data.global_chat_info) {
+        setGlobalChatInfo(data.global_chat_info);
+      }
+      if (data.chatbot_config) {
+        setUseCustomChatbot(true);
+        setChatbotProvider(data.chatbot_config.llm_service?.toLowerCase() || "openai");
+        setChatbotModelName(data.chatbot_config.llm_model || "");
+        setChatbotTemperature(String(data.chatbot_config.model_kwargs?.temperature ?? "0"));
+        // Load provider-specific config fields + masked auth
+        const cfg: Record<string, string> = {};
+        for (const key of ["base_url", "azure_deployment", "region_name", "project", "location", "endpoint_name", "endpoint_url"]) {
+          if (data.chatbot_config[key]) cfg[key] = data.chatbot_config[key];
+        }
+        if (data.chatbot_config.authentication_configuration) {
+          for (const [key, value] of Object.entries(data.chatbot_config.authentication_configuration)) {
+            if (typeof value === "string") cfg[key] = value;
+          }
+        }
+        setChatbotProviderConfig(cfg);
+      } else {
+        setUseCustomChatbot(false);
+      }
+
+      // Store graph overrides when in per-graph scope
+      if (data.graph_overrides) {
+        setGraphOverrides(data.graph_overrides);
+      } else {
+        setGraphOverrides({});
+      }
+
+      const currentDefaultModel = llmConfig.completion_service?.llm_model || "";
+      setSingleDefaultModel(currentDefaultModel);
+
+      // Load chat_service config for full mode (superadmin)
+      if (llmConfig.chat_service) {
+        setUseCustomChatbot(true);
+        setChatbotProvider(llmConfig.chat_service.llm_service?.toLowerCase() || "openai");
+        setChatbotModelName(llmConfig.chat_service.llm_model || "");
+        setChatbotTemperature(String(llmConfig.chat_service.model_kwargs?.temperature ?? "0"));
+        const chatCfg: Record<string, string> = {};
+        for (const key of ["base_url", "azure_deployment", "region_name", "project", "location", "endpoint_name", "endpoint_url"]) {
+          if (llmConfig.chat_service[key]) chatCfg[key] = llmConfig.chat_service[key];
+        }
+        if (llmConfig.chat_service.authentication_configuration) {
+          for (const [key, value] of Object.entries(llmConfig.chat_service.authentication_configuration)) {
+            if (typeof value === "string") chatCfg[key] = value;
+          }
+        }
+        setChatbotProviderConfig(chatCfg);
+      } else {
+        setUseCustomChatbot(false);
+        setChatbotProvider("openai");
+        setChatbotModelName("");
+        setChatbotTemperature("0");
+        setChatbotProviderConfig({});
+      }
+
+      // Detect if using multiple providers
+      const completionProv = llmConfig.completion_service?.llm_service?.toLowerCase();
+      const embeddingProv = llmConfig.embedding_service?.embedding_model_service?.toLowerCase();
+      const multimodalProv = llmConfig.multimodal_service?.llm_service?.toLowerCase();
+      const chatProv = llmConfig.chat_service?.llm_service?.toLowerCase();
+
+      const allSameProvider =
+        completionProv === embeddingProv &&
+        (!multimodalProv || completionProv === multimodalProv) &&
+        (!chatProv || completionProv === chatProv);
+      
+      setUseMultipleProviders(!allSameProvider);
+
+      // Helper: load config fields + masked auth fields from a service config
+      const loadServiceConfig = (svc: any, configKeys: string[]) => {
+        const cfg: Record<string, string> = {};
+        for (const key of configKeys) {
+          if (svc?.[key]) cfg[key] = svc[key];
+        }
+        // Load masked auth fields from authentication_configuration
+        if (svc?.authentication_configuration) {
+          for (const [key, value] of Object.entries(svc.authentication_configuration)) {
+            if (typeof value === "string") cfg[key] = value;
+          }
+        }
+        return cfg;
+      };
+
+      const completionConfigKeys = ["base_url", "azure_deployment", "region_name", "project", "location", "endpoint_name", "endpoint_url"];
+      const embeddingConfigKeys = ["base_url", "azure_deployment", "region_name"];
+
+      if (!allSameProvider) {
+        // Multi-provider mode - Load from backend
+        setCompletionProvider(completionProv || "openai");
+        setCompletionDefaultModel(llmConfig.completion_service?.llm_model || "");
+        setCompletionConfig(loadServiceConfig(llmConfig.completion_service, completionConfigKeys));
+
+        setEmbeddingProvider(embeddingProv || "openai");
+        setEmbeddingModel(llmConfig.embedding_service?.model_name || "");
+        setEmbeddingConfig(loadServiceConfig(llmConfig.embedding_service, embeddingConfigKeys));
+
+        setMultimodalProvider(multimodalProv || "openai");
+        setMultimodalModelName(llmConfig.multimodal_service?.llm_model || "");
+        setMultimodalConfig(loadServiceConfig(llmConfig.multimodal_service, ["azure_deployment"]));
+      } else {
+        // Single provider mode - Load from backend
+        setSingleProvider(completionProv || "openai");
+        setSingleDefaultModel(llmConfig.completion_service?.llm_model || "");
+        setSingleEmbeddingModel(llmConfig.embedding_service?.model_name || "");
+        setMultimodalModel(llmConfig.multimodal_service?.llm_model || "");
+        // Load config + auth from completion_service (single provider shares auth)
+        const singleCfg = loadServiceConfig(llmConfig.completion_service, completionConfigKeys);
+        // Also load top-level authentication_configuration (used in single-provider mode)
+        if (llmConfig.authentication_configuration) {
+          for (const [key, value] of Object.entries(llmConfig.authentication_configuration)) {
+            if (typeof value === "string" && !singleCfg[key]) singleCfg[key] = value;
+          }
+        }
+        setSingleConfig(singleCfg);
+      }
+    } catch (error: any) {
+      console.error("Error fetching config:", error);
+      setMessage(`Failed to load configuration: ${error.message}`);
+      setMessageType("error");
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  const clearTestResults = () => {
+    setConnectionTested(false);
+    setTestResults(null);
+    setMessage("");
+    setMessageType("");
+  };
+
+  // Update config when provider changes - CLEAR ALL FIELDS
+  const handleProviderChange = (newProvider: string, target: 'single' | 'completion' | 'embedding' | 'multimodal') => {
+    if (target === 'single') {
+      setSingleProvider(newProvider);
+      setSingleConfig({});
+      // Clear model names when switching provider
+      setSingleDefaultModel("");
+      setSingleEmbeddingModel("");
+      setMultimodalModel("");
+    } else if (target === 'completion') {
+      setCompletionProvider(newProvider);
+      setCompletionConfig({});
+      // Clear model names when switching provider
+      setCompletionDefaultModel("");
+    } else if (target === 'embedding') {
+      setEmbeddingProvider(newProvider);
+      setEmbeddingConfig({});
+      // Clear model name when switching provider
+      setEmbeddingModel("");
+    } else if (target === 'multimodal') {
+      setMultimodalProvider(newProvider);
+      setMultimodalConfig({});
+      // Clear model name when switching provider
+      setMultimodalModelName("");
+    }
+    clearTestResults();
+  };
+
+  const buildAuthConfig = (provider: string, config: Record<string, string>) => {
+    const authConfig: Record<string, string> = {};
+    const providerFields = PROVIDER_FIELDS[provider as keyof typeof PROVIDER_FIELDS];
+    if (!providerFields) return authConfig;
+    
+    providerFields.authFields.forEach(field => {
+      if (config[field.key]) {
+        authConfig[field.key] = config[field.key];
+      }
+    });
+    
+    return authConfig;
+  };
+
+  const buildServiceConfig = (provider: string, config: Record<string, string>) => {
+    const serviceConfig: Record<string, any> = {};
+    const providerFields = PROVIDER_FIELDS[provider as keyof typeof PROVIDER_FIELDS];
+    if (!providerFields) return serviceConfig;
+    
+    providerFields.configFields.forEach(field => {
+      if (config[field.key]) {
+        serviceConfig[field.key] = config[field.key];
+      }
+    });
+    
+    return serviceConfig;
+  };
+
+  const handleSave = async () => {
+    setIsSaving(true);
+    setMessage("");
+    setMessageType("");
+
+    try {
+      const creds = sessionStorage.getItem("creds");
+      let llmConfigData: any;
+
+      // Graph admin saving chatbot config
+      if (isChatbotOnlyMode) {
+        if (useCustomChatbot) {
+          const chatService: any = {
+            llm_service: chatbotProvider,
+            llm_model: chatbotModelName,
+            authentication_configuration: buildAuthConfig(chatbotProvider, chatbotProviderConfig),
+            model_kwargs: { temperature: parseFloat(chatbotTemperature) || 0 },
+            ...buildServiceConfig(chatbotProvider, chatbotProviderConfig),
+          };
+          llmConfigData = { graphname: selectedGraph || undefined, chat_service: chatService };
+        } else {
+          // Revert to inherit: send null chat_service
+          llmConfigData = { graphname: selectedGraph || undefined, chat_service: null };
+        }
+
+        const response = await fetch("/ui/config/llm", {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Basic ${creds}`,
+          },
+          body: JSON.stringify(llmConfigData),
+        });
+
+        if (!response.ok) {
+          const errorData = await response.json();
+          throw new Error(errorData.detail || "Failed to save configuration");
+        }
+
+        setMessage("Configuration saved successfully!");
+        setMessageType("success");
+        setTestResults(null);
+        setConnectionTested(false);
+        setIsSaving(false);
+        return;
+      }
+
+      if (useMultipleProviders) {
+        const completionServiceConfig: any = {
+          llm_service: completionProvider,
+          llm_model: completionDefaultModel,
+          authentication_configuration: buildAuthConfig(completionProvider, completionConfig),
+          model_kwargs: { temperature: 0 },
+          prompt_path: `./common/prompts/${getPromptPath(completionProvider)}/`,
+          ...buildServiceConfig(completionProvider, completionConfig)
+        };
+        
+        llmConfigData = {
+          graphname: selectedGraph || undefined,
+          completion_service: completionServiceConfig,
+          embedding_service: {
+            embedding_model_service: embeddingProvider,
+            model_name: embeddingModel,
+            authentication_configuration: buildAuthConfig(embeddingProvider, embeddingConfig),
+            ...buildServiceConfig(embeddingProvider, embeddingConfig)
+          },
+          multimodal_service: {
+            llm_service: multimodalProvider,
+            llm_model: multimodalModelName,
+            authentication_configuration: buildAuthConfig(multimodalProvider, multimodalConfig),
+            model_kwargs: { temperature: 0 },
+            ...buildServiceConfig(multimodalProvider, multimodalConfig)
+          },
+        };
+
+        // Save chat_service if not inheriting from completion service
+        if (useCustomChatbot) {
+          llmConfigData.chat_service = {
+            llm_service: chatbotProvider,
+            llm_model: chatbotModelName,
+            authentication_configuration: buildAuthConfig(chatbotProvider, chatbotProviderConfig),
+            model_kwargs: { temperature: parseFloat(chatbotTemperature) || 0 },
+            ...buildServiceConfig(chatbotProvider, chatbotProviderConfig),
+          };
+        } else {
+          llmConfigData.chat_service = null;
+        }
+      } else {
+        const completionServiceConfig: any = {
+          llm_service: singleProvider,
+          llm_model: singleDefaultModel,
+          model_kwargs: { temperature: 0 },
+          prompt_path: `./common/prompts/${getPromptPath(singleProvider)}/`,
+          ...buildServiceConfig(singleProvider, singleConfig)
+        };
+        
+        llmConfigData = {
+          graphname: selectedGraph || undefined,
+          authentication_configuration: buildAuthConfig(singleProvider, singleConfig),
+          completion_service: completionServiceConfig,
+          embedding_service: {
+            embedding_model_service: singleProvider,
+            model_name: singleEmbeddingModel,
+          },
+          multimodal_service: {
+            llm_service: singleProvider,
+            llm_model: multimodalModel,
+            model_kwargs: { temperature: 0 },
+            ...buildServiceConfig(singleProvider, singleConfig)
+          },
+        };
+
+        // Save chat_service with just the model name (same provider as completion)
+        if (chatbotModelName.trim()) {
+          llmConfigData.chat_service = {
+            llm_model: chatbotModelName,
+          };
+        } else {
+          llmConfigData.chat_service = null;
+        }
+      }
+
+      // Add scope for superadmin per-graph saves
+      if (configScope === "graph") {
+        llmConfigData.scope = "graph";
+      }
+
+      const response = await fetch("/ui/config/llm", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Basic ${creds}`,
+        },
+        body: JSON.stringify(llmConfigData),
+      });
+
+      if (!response.ok) {
+        const errorData = await response.json();
+        throw new Error(errorData.detail || "Failed to save configuration");
+      }
+
+      const scopeLabel = configScope === "graph" ? `graph "${selectedGraph}"` : "global";
+      setMessage(`Configuration saved successfully (${scopeLabel})!`);
+      setMessageType("success");
+      setTestResults(null);
+      setConnectionTested(false);
+    } catch (error: any) {
+      console.error("Error saving config:", error);
+      setMessage(`❌ Error: ${error.message}`);
+      setMessageType("error");
+    } finally {
+      setIsSaving(false);
+    }
+  };
+
+  const handleTestConnection = async () => {
+    setIsTesting(true);
+    setTestResults(null);
+    setMessage("");
+    setMessageType("");
+
+    try {
+      // Frontend validation
+      const validateProvider = (provider: string, config: Record<string, string>, serviceName: string) => {
+        const providerFields = PROVIDER_FIELDS[provider as keyof typeof PROVIDER_FIELDS];
+        if (!providerFields) return null;
+        
+        for (const field of providerFields.authFields) {
+          if (field.required && (!config[field.key] || !config[field.key].trim())) {
+            return `${field.label} is required for ${serviceName}`;
+          }
+        }
+        for (const field of providerFields.configFields) {
+          if (field.required && (!config[field.key] || !config[field.key].trim())) {
+            return `${field.label} is required for ${serviceName}`;
+          }
+        }
+        return null;
+      };
+
+      if (useMultipleProviders) {
+        const completionError = validateProvider(completionProvider, completionConfig, "Completion Service");
+        if (completionError) {
+          setMessage(`❌ ${completionError}`);
+          setMessageType("error");
+          setIsTesting(false);
+          return;
+        }
+        
+        const embeddingError = validateProvider(embeddingProvider, embeddingConfig, "Embedding Service");
+        if (embeddingError) {
+          setMessage(`❌ ${embeddingError}`);
+          setMessageType("error");
+          setIsTesting(false);
+          return;
+        }
+
+        const multimodalError = validateProvider(multimodalProvider, multimodalConfig, "Multimodal Service");
+        if (multimodalError) {
+          setMessage(`❌ ${multimodalError}`);
+          setMessageType("error");
+          setIsTesting(false);
+          return;
+        }
+      } else {
+        const singleError = validateProvider(singleProvider, singleConfig, singleProvider);
+        if (singleError) {
+          setMessage(`❌ ${singleError}`);
+          setMessageType("error");
+          setIsTesting(false);
+          return;
+        }
+      }
+      
+      const creds = sessionStorage.getItem("creds");
+      let llmConfigData: any;
+
+      if (useMultipleProviders) {
+        llmConfigData = {
+          graphname: selectedGraph || undefined,
+          completion_service: {
+            llm_service: completionProvider,
+            llm_model: completionDefaultModel,
+            authentication_configuration: buildAuthConfig(completionProvider, completionConfig),
+            ...buildServiceConfig(completionProvider, completionConfig)
+          },
+          embedding_service: {
+            embedding_model_service: embeddingProvider,
+            model_name: embeddingModel,
+            authentication_configuration: buildAuthConfig(embeddingProvider, embeddingConfig),
+            ...buildServiceConfig(embeddingProvider, embeddingConfig)
+          },
+        };
+        
+        llmConfigData.multimodal_service = {
+          llm_service: multimodalProvider,
+          llm_model: multimodalModelName,
+          authentication_configuration: buildAuthConfig(multimodalProvider, multimodalConfig),
+          ...buildServiceConfig(multimodalProvider, multimodalConfig)
+        };
+      } else {
+        llmConfigData = {
+          graphname: selectedGraph || undefined,
+          authentication_configuration: buildAuthConfig(singleProvider, singleConfig),
+          completion_service: {
+            llm_service: singleProvider,
+            llm_model: singleDefaultModel,
+            ...buildServiceConfig(singleProvider, singleConfig)
+          },
+          embedding_service: {
+            embedding_model_service: singleProvider,
+            model_name: singleEmbeddingModel,
+          },
+          multimodal_service: {
+            llm_service: singleProvider,
+            llm_model: multimodalModel,
+            ...buildServiceConfig(singleProvider, singleConfig)
+          },
+        };
+        
+      }
+
+      // Add chat_service to test config if custom chatbot is configured
+      // Add chat_service to test config if not inheriting
+      if (useCustomChatbot) {
+        if (useMultipleProviders) {
+          const chatbotError = validateProvider(chatbotProvider, chatbotProviderConfig, "Chatbot Service");
+          if (chatbotError) {
+            setMessage(`❌ ${chatbotError}`);
+            setMessageType("error");
+            setIsTesting(false);
+            return;
+          }
+          llmConfigData.chat_service = {
+            llm_service: chatbotProvider,
+            llm_model: chatbotModelName,
+            authentication_configuration: buildAuthConfig(chatbotProvider, chatbotProviderConfig),
+            model_kwargs: { temperature: parseFloat(chatbotTemperature) || 0 },
+            ...buildServiceConfig(chatbotProvider, chatbotProviderConfig),
+          };
+        } else if (chatbotModelName.trim()) {
+          llmConfigData.chat_service = {
+            llm_model: chatbotModelName,
+          };
+        }
+      }
+
+      const response = await fetch("/ui/config/llm/test", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Basic ${creds}`,
+        },
+        body: JSON.stringify(llmConfigData),
+      });
+
+      if (!response.ok) {
+        const errorData = await response.json();
+        throw new Error(errorData.detail || "Connection test failed");
+      }
+
+      const result = await response.json();
+      setTestResults(result.results);
+      
+      if (result.status === "success") {
+        setMessage("✅ All connection tests passed successfully!");
+        setMessageType("success");
+        setConnectionTested(true);
+      } else {
+        setMessage("⚠️ Some connection tests failed. See details below.");
+        setMessageType("error");
+        setConnectionTested(false);
+      }
+      
+    } catch (error: any) {
+      console.error("Error testing connection:", error);
+      setMessage(`❌ Error: ${error.message}`);
+      setMessageType("error");
+    } finally {
+      setIsTesting(false);
+    }
+  };
+
+  const getPromptPath = (provider: string) => {
+    const providerMap: Record<string, string> = {
+      openai: "openai_gpt4",
+      azure: "openai_gpt4",
+      genai: "google_gemini",
+      vertexai: "gcp_vertexai_palm",
+      bedrock: "aws_bedrock_claude3haiku",
+    };
+    return providerMap[provider] || "openai_gpt4";
+  };
+
+  // Get placeholder text based on provider
+  const getModelPlaceholder = (provider: string, modelType: 'llm' | 'embedding' | 'multimodal') => {
+    const placeholders: Record<string, Record<string, string>> = {
+      openai: {
+        llm: "e.g., gpt-4o-mini, gpt-4o, gpt-4-turbo",
+        embedding: "e.g., text-embedding-3-small, text-embedding-3-large",
+        multimodal: "e.g., gpt-4o, gpt-4-turbo"
+      },
+      azure: {
+        llm: "e.g., gpt-4, gpt-35-turbo (your deployment name)",
+        embedding: "e.g., text-embedding-ada-002 (your deployment name)",
+        multimodal: "e.g., gpt-4-vision (your deployment name)"
+      },
+      genai: {
+        llm: "e.g., gemini-1.5-flash, gemini-1.5-pro",
+        embedding: "e.g., models/text-embedding-004",
+        multimodal: "e.g., gemini-1.5-flash, gemini-1.5-pro"
+      },
+      vertexai: {
+        llm: "e.g., gemini-1.5-flash, text-bison",
+        embedding: "e.g., text-embedding-004, textembedding-gecko",
+        multimodal: "e.g., gemini-1.5-flash, gemini-pro-vision"
+      },
+      bedrock: {
+        llm: "e.g., anthropic.claude-3-haiku-20240307-v1:0",
+        embedding: "e.g., amazon.titan-embed-text-v1",
+        multimodal: "e.g., anthropic.claude-3-sonnet-20240229-v1:0"
+      },
+      groq: {
+        llm: "e.g., llama-3.1-70b-versatile, mixtral-8x7b-32768",
+        embedding: "Not supported",
+        multimodal: "Not supported"
+      },
+      ollama: {
+        llm: "e.g., llama3.2, llama3.1, mistral",
+        embedding: "e.g., nomic-embed-text, mxbai-embed-large",
+        multimodal: "e.g., llama3.2-vision, llava"
+      },
+      sagemaker: {
+        llm: "Your SageMaker endpoint name",
+        embedding: "Not supported",
+        multimodal: "Not supported"
+      },
+      huggingface: {
+        llm: "e.g., meta-llama/Meta-Llama-3-8B-Instruct",
+        embedding: "Not supported",
+        multimodal: "Not supported"
+      },
+      watsonx: {
+        llm: "e.g., ibm/granite-13b-chat-v2",
+        embedding: "Not supported",
+        multimodal: "Not supported"
+      }
+    };
+    
+    return placeholders[provider]?.[modelType] || "Enter model name";
+  };
+
+  // Render provider-specific fields
+  const renderProviderFields = (provider: string, config: Record<string, string>, setConfig: (config: Record<string, string>) => void) => {
+    const providerFields = PROVIDER_FIELDS[provider as keyof typeof PROVIDER_FIELDS];
+    if (!providerFields) return null;
+
+    const handleFieldChange = (key: string, value: string) => {
+      setConfig({ ...config, [key]: value });
+      clearTestResults();
+    };
+
+    return (
+      <>
+        {providerFields.note && (
+          <div className="p-3 bg-blue-50 dark:bg-blue-900/20 text-blue-700 dark:text-blue-300 text-sm rounded-lg">
+            ℹ️ {providerFields.note}
+          </div>
+        )}
+        
+        {providerFields.authFields.map(field => (
+          <div key={field.key}>
+            <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+              {field.label} {field.required && <span className="text-red-500">*</span>}
+            </label>
+            <Input
+              type={field.type}
+              className="dark:border-[#3D3D3D] dark:bg-background"
+              placeholder={field.placeholder || ""}
+              value={config[field.key] || ""}
+              onChange={(e) => handleFieldChange(field.key, e.target.value)}
+            />
+          </div>
+        ))}
+        
+        {providerFields.configFields.map(field => (
+          <div key={field.key}>
+            <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+              {field.label} {field.required && <span className="text-red-500">*</span>}
+            </label>
+            <Input
+              type={field.type}
+              className="dark:border-[#3D3D3D] dark:bg-background"
+              placeholder={field.placeholder || ""}
+              value={config[field.key] || ""}
+              onChange={(e) => handleFieldChange(field.key, e.target.value)}
+            />
+          </div>
+        ))}
+      </>
+    );
+  };
+
+  if (isLoading) {
+    return (
+      <div className="p-8 flex items-center justify-center">
+        <Loader2 className="h-8 w-8 animate-spin text-tigerOrange" />
+      </div>
+    );
+  }
+
+  if (isChatbotOnlyMode) {
+    return (
+      <div className="p-8">
+        <div className="max-w-5xl mx-auto">
+          <div className="mb-8">
+            <div className="flex items-center gap-3 mb-4">
+              <div className="w-12 h-12 rounded-full bg-tigerOrange/10 flex items-center justify-center">
+                <Server className="h-6 w-6 text-tigerOrange" />
+              </div>
+              <div>
+                <h1 className="text-2xl font-bold text-black dark:text-white">
+                  Chatbot LLM Configuration
+                </h1>
+                <p className="text-sm text-gray-600 dark:text-[#D9D9D9]">
+                  Configure the LLM provider and model for the chatbot.
+                </p>
+              </div>
+            </div>
+          </div>
+
+          <ConfigScopeToggle
+            configScope="graph"
+            selectedGraph={selectedGraph}
+            availableGraphs={availableGraphs}
+            graphOnly={true}
+            className="mb-6"
+            onScopeChange={() => {}}
+            onGraphChange={(value) => {
+              setSelectedGraph(value);
+              sessionStorage.setItem("selectedGraph", value);
+              window.dispatchEvent(new Event("graphrag:selectedGraph"));
+              clearTestResults();
+              fetchConfig(undefined, value);
+            }}
+          />
+
+          <div className="space-y-6">
+            {/* Mode toggle */}
+            <div className="bg-white dark:bg-shadeA border border-gray-300 dark:border-[#3D3D3D] rounded-lg p-6">
+              <div className="space-y-4">
+                <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                  Configuration Mode
+                </label>
+                <div className="flex gap-4">
+                  <label className="flex items-center gap-2 cursor-pointer">
+                    <input
+                      type="radio"
+                      name="chatbotConfigMode"
+                      checked={!useCustomChatbot}
+                      onChange={() => { setUseCustomChatbot(false); clearTestResults(); }}
+                      className="h-4 w-4"
+                    />
+                    <span className="text-sm text-black dark:text-white">Inherit from global config</span>
+                  </label>
+                  <label className="flex items-center gap-2 cursor-pointer">
+                    <input
+                      type="radio"
+                      name="chatbotConfigMode"
+                      checked={useCustomChatbot}
+                      onChange={() => { setUseCustomChatbot(true); clearTestResults(); }}
+                      className="h-4 w-4"
+                    />
+                    <span className="text-sm text-black dark:text-white">Use custom LLM provider</span>
+                  </label>
+                </div>
+                {!useCustomChatbot && globalChatInfo.llm_service && (
+                  <p className="text-xs text-gray-500 dark:text-gray-400">
+                    Currently inherited: {globalChatInfo.llm_service} / {globalChatInfo.llm_model}
+                  </p>
+                )}
+              </div>
+            </div>
+
+            {/* Custom provider config */}
+            {useCustomChatbot && (
+              <div className="bg-white dark:bg-shadeA border border-gray-300 dark:border-[#3D3D3D] rounded-lg p-6">
+                <h3 className="text-lg font-semibold mb-4 text-black dark:text-white">Custom Chatbot Provider</h3>
+                <div className="space-y-4">
+                  <div>
+                    <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                      LLM Provider <span className="text-red-500">*</span>
+                    </label>
+                    <Select
+                      value={chatbotProvider}
+                      onValueChange={(value) => {
+                        setChatbotProvider(value);
+                        setChatbotProviderConfig({});
+                        setChatbotModelName("");
+                        clearTestResults();
+                      }}
+                    >
+                      <SelectTrigger className="dark:border-[#3D3D3D] dark:bg-background">
+                        <SelectValue />
+                      </SelectTrigger>
+                      <SelectContent>
+                        <SelectItem value="openai">OpenAI</SelectItem>
+                        <SelectItem value="azure">Azure OpenAI</SelectItem>
+                        <SelectItem value="genai">Google GenAI (Gemini)</SelectItem>
+                        <SelectItem value="vertexai">Google Vertex AI</SelectItem>
+                        <SelectItem value="bedrock">AWS Bedrock</SelectItem>
+                        <SelectItem value="groq">Groq</SelectItem>
+                        <SelectItem value="ollama">Ollama</SelectItem>
+                        <SelectItem value="sagemaker">AWS SageMaker</SelectItem>
+                        <SelectItem value="huggingface">HuggingFace</SelectItem>
+                        <SelectItem value="watsonx">IBM WatsonX</SelectItem>
+                      </SelectContent>
+                    </Select>
+                  </div>
+
+                  {renderProviderFields(chatbotProvider, chatbotProviderConfig, setChatbotProviderConfig)}
+
+                  <div>
+                    <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                      Model Name <span className="text-red-500">*</span>
+                    </label>
+                    <Input
+                      type="text"
+                      className="dark:border-[#3D3D3D] dark:bg-background"
+                      placeholder={getModelPlaceholder(chatbotProvider, 'llm')}
+                      value={chatbotModelName}
+                      onChange={(e) => { setChatbotModelName(e.target.value); clearTestResults(); }}
+                    />
+                  </div>
+
+                  <div>
+                    <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                      Temperature
+                    </label>
+                    <Input
+                      type="number"
+                      className="dark:border-[#3D3D3D] dark:bg-background"
+                      placeholder="0"
+                      min="0"
+                      max="2"
+                      step="0.1"
+                      value={chatbotTemperature}
+                      onChange={(e) => { setChatbotTemperature(e.target.value); clearTestResults(); }}
+                    />
+                  </div>
+                </div>
+              </div>
+            )}
+
+            {/* Test results */}
+            {testResults && (
+              <div className="bg-white dark:bg-shadeA border border-gray-300 dark:border-[#3D3D3D] rounded-lg p-6">
+                <h3 className="text-lg font-semibold mb-4 text-black dark:text-white">Test Results</h3>
+                {Object.entries(testResults).map(([key, result]: [string, any]) => (
+                  <div key={key} className={`p-3 rounded-lg text-sm mb-2 ${
+                    result.status === "success"
+                      ? "bg-green-50 dark:bg-green-900/20 text-green-700 dark:text-green-300"
+                      : result.status === "error"
+                      ? "bg-red-50 dark:bg-red-900/20 text-red-700 dark:text-red-300"
+                      : "bg-gray-50 dark:bg-gray-900/20 text-gray-500"
+                  }`}>
+                    {result.message || `${key}: ${result.status}`}
+                  </div>
+                ))}
+              </div>
+            )}
+
+            {message && (
+              <div
+                className={`p-4 rounded-lg text-sm mb-4 ${
+                  messageType === "success"
+                    ? "bg-green-50 dark:bg-green-900/20 text-green-700 dark:text-green-300"
+                    : "bg-red-50 dark:bg-red-900/20 text-red-700 dark:text-red-300"
+                }`}
+              >
+                {message}
+              </div>
+            )}
+
+            <div className="flex gap-3">
+              {useCustomChatbot && (
+                <Button
+                  onClick={handleTestConnection}
+                  disabled={isSaving || isTesting}
+                  variant="outline"
+                  className="flex-1"
+                >
+                  {isTesting ? (
+                    <>
+                      <Loader2 className="h-4 w-4 mr-2 animate-spin" />
+                      Testing...
+                    </>
+                  ) : (
+                    <>
+                      <CheckCircle2 className="h-4 w-4 mr-2" />
+                      Test Connection
+                    </>
+                  )}
+                </Button>
+              )}
+              <Button
+                onClick={handleSave}
+                disabled={isSaving || isTesting || (useCustomChatbot && !connectionTested)}
+                className="gradient text-white flex-1"
+              >
+                {isSaving ? (
+                  <>
+                    <Loader2 className="h-4 w-4 mr-2 animate-spin" />
+                    Saving...
+                  </>
+                ) : (
+                  <>
+                    <Save className="h-4 w-4 mr-2" />
+                    Save Configuration
+                  </>
+                )}
+              </Button>
+            </div>
+          </div>
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <div className="p-8">
+      <div className="max-w-5xl mx-auto">
+        <div className="mb-8">
+          <div className="flex items-center gap-3 mb-4">
+            <div className="w-12 h-12 rounded-full bg-tigerOrange/10 flex items-center justify-center">
+              <Server className="h-6 w-6 text-tigerOrange" />
+            </div>
+            <div>
+              <h1 className="text-2xl font-bold text-black dark:text-white">
+                LLM Configuration
+              </h1>
+              <p className="text-sm text-gray-600 dark:text-[#D9D9D9]">
+                Configure your Large Language Model provider settings
+              </p>
+            </div>
+          </div>
+        </div>
+
+        <fieldset>
+        <div className="space-y-6">
+          {/* Config Scope Toggle (superadmin) */}
+          <ConfigScopeToggle
+            configScope={configScope}
+            selectedGraph={selectedGraph}
+            availableGraphs={availableGraphs}
+            className=""
+            onScopeChange={(scope) => {
+              setConfigScope(scope);
+              clearTestResults();
+              if (scope === "global") {
+                fetchConfig("global");
+              } else if (selectedGraph) {
+                fetchConfig("graph", selectedGraph);
+              }
+            }}
+            onGraphChange={(value) => {
+              setConfigScope("graph");
+              setSelectedGraph(value);
+              sessionStorage.setItem("selectedGraph", value);
+              window.dispatchEvent(new Event("graphrag:selectedGraph"));
+              clearTestResults();
+              fetchConfig("graph", value);
+            }}
+            graphSelectedHint={
+              Object.keys(graphOverrides).length > 0
+                ? `Overridden services: ${Object.keys(graphOverrides).join(", ")}. Other settings are inherited from global.`
+                : "No per-graph overrides set. All settings are inherited from global defaults."
+            }
+          />
+
+          {/* Multi-Provider Toggle */}
+          <div className="bg-white dark:bg-shadeA border border-gray-300 dark:border-[#3D3D3D] rounded-lg p-6">
+            <div className="flex items-center space-x-3">
+              <input
+                type="checkbox"
+                id="multiProvider"
+                checked={useMultipleProviders}
+                onChange={(e) => {
+                  setUseMultipleProviders(e.target.checked);
+                  clearTestResults();
+                }}
+                className="h-4 w-4 rounded border-gray-300 dark:border-[#3D3D3D]"
+              />
+              <label htmlFor="multiProvider" className="text-sm font-medium text-black dark:text-white">
+                Use different providers for different services
+              </label>
+            </div>
+            <p className="text-xs text-gray-500 dark:text-gray-400 mt-2 ml-7">
+              Enable this to configure separate providers for chat completion, embeddings, and multimodal services
+            </p>
+          </div>
+
+          {/* Single Provider Configuration */}
+          {!useMultipleProviders && (
+            <div className="bg-white dark:bg-shadeA border border-gray-300 dark:border-[#3D3D3D] rounded-lg p-6">
+              <div className="space-y-6">
+                <div>
+                  <h2 className="text-lg font-semibold mb-4 text-black dark:text-white">
+                    Provider Settings
+                  </h2>
+                  <p className="text-sm text-gray-600 dark:text-[#D9D9D9] mb-6">
+                    Configure your LLM provider settings for all services.
+                  </p>
+
+                  <div className="space-y-4">
+                    <div>
+                      <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                        Provider
+                      </label>
+                      <Select value={singleProvider} onValueChange={(value) => handleProviderChange(value, 'single')}>
+                        <SelectTrigger className="dark:border-[#3D3D3D] dark:bg-background">
+                          <SelectValue placeholder="Select provider" />
+                        </SelectTrigger>
+                        <SelectContent>
+                          <SelectItem value="openai">OpenAI</SelectItem>
+                          <SelectItem value="azure">Azure OpenAI</SelectItem>
+                          <SelectItem value="genai">Google GenAI (Gemini)</SelectItem>
+                          <SelectItem value="vertexai">Google Vertex AI</SelectItem>
+                          <SelectItem value="bedrock">AWS Bedrock</SelectItem>
+                          <SelectItem value="ollama">Ollama</SelectItem>
+                        </SelectContent>
+                      </Select>
+                      <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                        Only providers supporting both completion and embedding services are shown
+                      </p>
+                    </div>
+
+                    {renderProviderFields(singleProvider, singleConfig, setSingleConfig)}
+
+                    <div>
+                      <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                        Completion Model
+                      </label>
+                      <Input
+                        type="text"
+                        className="dark:border-[#3D3D3D] dark:bg-background"
+                        placeholder={getModelPlaceholder(singleProvider, 'llm')}
+                        value={singleDefaultModel}
+                        onChange={(e) => {
+                          setSingleDefaultModel(e.target.value);
+                          clearTestResults();
+                        }}
+                      />
+                      <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                        Used by ECC for entity extraction and community summarization during document ingestion
+                      </p>
+                    </div>
+
+                    <div>
+                      <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                        Chatbot Model
+                      </label>
+                      <div className="flex items-center space-x-2 mb-2">
+                        <input
+                          type="checkbox"
+                          id="inheritChatbotModel"
+                          className="rounded border-gray-300 dark:border-[#3D3D3D]"
+                          checked={!useCustomChatbot}
+                          onChange={(e) => {
+                            setUseCustomChatbot(!e.target.checked);
+                            if (e.target.checked) {
+                              setChatbotModelName("");
+                            }
+                            clearTestResults();
+                          }}
+                        />
+                        <label htmlFor="inheritChatbotModel" className="text-sm text-black dark:text-white">
+                          Use same model as completion service
+                        </label>
+                      </div>
+                      {useCustomChatbot && (
+                        <Input
+                          type="text"
+                          className="dark:border-[#3D3D3D] dark:bg-background"
+                          placeholder={getModelPlaceholder(singleProvider, 'llm')}
+                          value={chatbotModelName}
+                          onChange={(e) => {
+                            setChatbotModelName(e.target.value);
+                            clearTestResults();
+                          }}
+                        />
+                      )}
+                      <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                        Used by the chatbot for answering user questions
+                      </p>
+                    </div>
+
+                    <div>
+                      <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                        Embedding Model
+                      </label>
+                      <Input
+                        type="text"
+                        className="dark:border-[#3D3D3D] dark:bg-background"
+                        placeholder={getModelPlaceholder(singleProvider, 'embedding')}
+                        value={singleEmbeddingModel}
+                        onChange={(e) => {
+                          setSingleEmbeddingModel(e.target.value);
+                          clearTestResults();
+                        }}
+                      />
+                      <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                        Used for generating vector embeddings of document chunks
+                      </p>
+                    </div>
+
+                    <div>
+                      <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                        Multimodal Model
+                      </label>
+                      <Input
+                        type="text"
+                        className="dark:border-[#3D3D3D] dark:bg-background"
+                        placeholder={getModelPlaceholder(singleProvider, 'multimodal')}
+                        value={multimodalModel}
+                        onChange={(e) => {
+                          setMultimodalModel(e.target.value);
+                          clearTestResults();
+                        }}
+                      />
+                      <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                        Used for processing images and multimodal content
+                      </p>
+                    </div>
+                  </div>
+                </div>
+              </div>
+            </div>
+          )}
+
+          {/* Multiple Provider Configuration */}
+          {useMultipleProviders && (
+            <>
+              {/* Completion Provider */}
+              <div className="bg-white dark:bg-shadeA border border-gray-300 dark:border-[#3D3D3D] rounded-lg p-6">
+                <h2 className="text-lg font-semibold mb-4 text-black dark:text-white">
+                  Completion Service
+                </h2>
+                <p className="text-sm text-gray-600 dark:text-[#D9D9D9] mb-6">
+                  Configure the LLM provider used by the ECC service for document processing (entity extraction and community summarization)
+                </p>
+
+                <div className="space-y-4">
+                  <div>
+                    <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                      Provider
+                    </label>
+                    <Select value={completionProvider} onValueChange={(value) => handleProviderChange(value, 'completion')}>
+                      <SelectTrigger className="dark:border-[#3D3D3D] dark:bg-background">
+                        <SelectValue placeholder="Select provider" />
+                      </SelectTrigger>
+                      <SelectContent>
+                        <SelectItem value="openai">OpenAI</SelectItem>
+                        <SelectItem value="azure">Azure OpenAI</SelectItem>
+                        <SelectItem value="genai">Google GenAI (Gemini)</SelectItem>
+                        <SelectItem value="vertexai">Google Vertex AI</SelectItem>
+                        <SelectItem value="bedrock">AWS Bedrock</SelectItem>
+                        <SelectItem value="sagemaker">AWS SageMaker</SelectItem>
+                        <SelectItem value="groq">Groq</SelectItem>
+                        <SelectItem value="ollama">Ollama</SelectItem>
+                        <SelectItem value="huggingface">HuggingFace</SelectItem>
+                        <SelectItem value="watsonx">IBM WatsonX</SelectItem>
+                      </SelectContent>
+                    </Select>
+                  </div>
+
+                  {renderProviderFields(completionProvider, completionConfig, setCompletionConfig)}
+
+                  <div>
+                    <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                      Completion Model
+                    </label>
+                    <Input
+                      type="text"
+                      className="dark:border-[#3D3D3D] dark:bg-background"
+                      placeholder={getModelPlaceholder(completionProvider, 'llm')}
+                      value={completionDefaultModel}
+                      onChange={(e) => {
+                        setCompletionDefaultModel(e.target.value);
+                        clearTestResults();
+                      }}
+                    />
+                    <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                      Used by ECC for entity extraction and community summarization during document ingestion
+                    </p>
+                  </div>
+                </div>
+              </div>
+
+              {/* Chatbot Service */}
+              <div className="bg-white dark:bg-shadeA border border-gray-300 dark:border-[#3D3D3D] rounded-lg p-6">
+                <h2 className="text-lg font-semibold mb-4 text-black dark:text-white">
+                  Chatbot Service
+                </h2>
+                <p className="text-sm text-gray-600 dark:text-[#D9D9D9] mb-4">
+                  Configure the LLM provider and model used by the chatbot for answering user questions.
+                </p>
+
+                <div className="space-y-4">
+                  <div className="flex items-center space-x-2">
+                    <input
+                      type="checkbox"
+                      id="inheritChatbotService"
+                      className="rounded border-gray-300 dark:border-[#3D3D3D]"
+                      checked={!useCustomChatbot}
+                      onChange={(e) => {
+                        setUseCustomChatbot(!e.target.checked);
+                        if (e.target.checked) {
+                          setChatbotModelName("");
+                          setChatbotProviderConfig({});
+                        }
+                        clearTestResults();
+                      }}
+                    />
+                    <label htmlFor="inheritChatbotService" className="text-sm font-medium text-black dark:text-white">
+                      Inherit from completion service
+                    </label>
+                  </div>
+
+                  {useCustomChatbot && (
+                    <>
+                      <div>
+                        <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                          Provider <span className="text-red-500">*</span>
+                        </label>
+                        <Select
+                          value={chatbotProvider}
+                          onValueChange={(value) => {
+                            setChatbotProvider(value);
+                            setChatbotProviderConfig({});
+                            setChatbotModelName("");
+                            clearTestResults();
+                          }}
+                        >
+                          <SelectTrigger className="dark:border-[#3D3D3D] dark:bg-background">
+                            <SelectValue />
+                          </SelectTrigger>
+                          <SelectContent>
+                            <SelectItem value="openai">OpenAI</SelectItem>
+                            <SelectItem value="azure">Azure OpenAI</SelectItem>
+                            <SelectItem value="genai">Google GenAI (Gemini)</SelectItem>
+                            <SelectItem value="vertexai">Google Vertex AI</SelectItem>
+                            <SelectItem value="bedrock">AWS Bedrock</SelectItem>
+                            <SelectItem value="groq">Groq</SelectItem>
+                            <SelectItem value="ollama">Ollama</SelectItem>
+                            <SelectItem value="sagemaker">AWS SageMaker</SelectItem>
+                            <SelectItem value="huggingface">HuggingFace</SelectItem>
+                            <SelectItem value="watsonx">IBM WatsonX</SelectItem>
+                          </SelectContent>
+                        </Select>
+                      </div>
+
+                      {renderProviderFields(chatbotProvider, chatbotProviderConfig, setChatbotProviderConfig)}
+
+                      <div>
+                        <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                          Model Name <span className="text-red-500">*</span>
+                        </label>
+                        <Input
+                          type="text"
+                          className="dark:border-[#3D3D3D] dark:bg-background"
+                          placeholder={getModelPlaceholder(chatbotProvider, 'llm')}
+                          value={chatbotModelName}
+                          onChange={(e) => { setChatbotModelName(e.target.value); clearTestResults(); }}
+                        />
+                      </div>
+
+                      <div>
+                        <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                          Temperature
+                        </label>
+                        <Input
+                          type="number"
+                          className="dark:border-[#3D3D3D] dark:bg-background"
+                          placeholder="0"
+                          min="0"
+                          max="2"
+                          step="0.1"
+                          value={chatbotTemperature}
+                          onChange={(e) => { setChatbotTemperature(e.target.value); clearTestResults(); }}
+                        />
+                      </div>
+                    </>
+                  )}
+                </div>
+              </div>
+
+              {/* Embedding Service Provider */}
+              <div className="bg-white dark:bg-shadeA border border-gray-300 dark:border-[#3D3D3D] rounded-lg p-6">
+                <h2 className="text-lg font-semibold mb-4 text-black dark:text-white">
+                  Embedding Service
+                </h2>
+                <p className="text-sm text-gray-600 dark:text-[#D9D9D9] mb-6">
+                  Configure the provider for generating embeddings.
+                </p>
+
+                <div className="space-y-4">
+                  <div>
+                    <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                      Provider
+                    </label>
+                    <Select value={embeddingProvider} onValueChange={(value) => handleProviderChange(value, 'embedding')}>
+                      <SelectTrigger className="dark:border-[#3D3D3D] dark:bg-background">
+                        <SelectValue placeholder="Select provider" />
+                      </SelectTrigger>
+                      <SelectContent>
+                        <SelectItem value="openai">OpenAI</SelectItem>
+                        <SelectItem value="azure">Azure OpenAI</SelectItem>
+                        <SelectItem value="genai">Google GenAI</SelectItem>
+                        <SelectItem value="vertexai">Google Vertex AI</SelectItem>
+                        <SelectItem value="bedrock">AWS Bedrock</SelectItem>
+                        <SelectItem value="ollama">Ollama</SelectItem>
+                      </SelectContent>
+                    </Select>
+                  </div>
+
+                  {renderProviderFields(embeddingProvider, embeddingConfig, setEmbeddingConfig)}
+
+                  <div>
+                    <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                      Embedding Model
+                    </label>
+                    <Input
+                      type="text"
+                      className="dark:border-[#3D3D3D] dark:bg-background"
+                      placeholder={getModelPlaceholder(embeddingProvider, 'embedding')}
+                      value={embeddingModel}
+                      onChange={(e) => {
+                        setEmbeddingModel(e.target.value);
+                        clearTestResults();
+                      }}
+                    />
+                  </div>
+                </div>
+              </div>
+
+              {/* Multimodal Service Provider */}
+              <div className="bg-white dark:bg-shadeA border border-gray-300 dark:border-[#3D3D3D] rounded-lg p-6">
+                <h2 className="text-lg font-semibold mb-4 text-black dark:text-white">
+                  Multimodal Service
+                </h2>
+                <p className="text-sm text-gray-600 dark:text-[#D9D9D9] mb-6">
+                  Configure the provider for processing images and multimodal content (vision tasks).
+                </p>
+
+                <div className="space-y-4">
+                  <div>
+                    <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                      Provider
+                    </label>
+                    <Select value={multimodalProvider} onValueChange={(value) => handleProviderChange(value, 'multimodal')}>
+                      <SelectTrigger className="dark:border-[#3D3D3D] dark:bg-background">
+                        <SelectValue placeholder="Select provider" />
+                      </SelectTrigger>
+                      <SelectContent>
+                        <SelectItem value="openai">OpenAI</SelectItem>
+                        <SelectItem value="azure">Azure OpenAI</SelectItem>
+                        <SelectItem value="genai">Google GenAI (Gemini)</SelectItem>
+                        <SelectItem value="vertexai">Google Vertex AI</SelectItem>
+                      </SelectContent>
+                    </Select>
+                    <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                      Only OpenAI, Azure, GenAI, VertexAI support vision
+                    </p>
+                  </div>
+
+                  {renderProviderFields(multimodalProvider, multimodalConfig, setMultimodalConfig)}
+
+                  <div>
+                    <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                      Model Name
+                    </label>
+                    <Input
+                      type="text"
+                      className="dark:border-[#3D3D3D] dark:bg-background"
+                      placeholder={getModelPlaceholder(multimodalProvider, 'multimodal')}
+                      value={multimodalModelName}
+                      onChange={(e) => {
+                        setMultimodalModelName(e.target.value);
+                        clearTestResults();
+                      }}
+                    />
+                  </div>
+                </div>
+              </div>
+            </>
+          )}
+
+
+          {message && (
+            <div
+              className={`p-4 rounded-lg text-sm mb-4 ${
+                messageType === "success"
+                  ? "bg-green-50 dark:bg-green-900/20 text-green-700 dark:text-green-300"
+                  : "bg-red-50 dark:bg-red-900/20 text-red-700 dark:text-red-300"
+              }`}
+            >
+              {message}
+            </div>
+          )}
+
+          {/* Test Results */}
+          {testResults && (
+            <div className="space-y-3 mb-4">
+              <h3 className="text-sm font-semibold text-black dark:text-white">Connection Test Results:</h3>
+              
+              {testResults.completion && testResults.completion.status !== "not_tested" && (
+                <div className={`p-3 rounded-lg text-sm ${
+                  testResults.completion.status === "success"
+                    ? "bg-green-50 dark:bg-green-900/20 text-green-700 dark:text-green-300"
+                    : "bg-red-50 dark:bg-red-900/20 text-red-700 dark:text-red-300"
+                }`}>
+                  <strong>Default LLM Model:</strong> {testResults.completion.message}
+                </div>
+              )}
+              
+              {testResults.chatbot && testResults.chatbot.status !== "not_tested" && (
+                <div className={`p-3 rounded-lg text-sm ${
+                  testResults.chatbot.status === "success"
+                    ? "bg-green-50 dark:bg-green-900/20 text-green-700 dark:text-green-300"
+                    : "bg-red-50 dark:bg-red-900/20 text-red-700 dark:text-red-300"
+                }`}>
+                  <strong>Chatbot LLM Model:</strong> {testResults.chatbot.message}
+                </div>
+              )}
+              
+              {testResults.embedding && testResults.embedding.status !== "not_tested" && (
+                <div className={`p-3 rounded-lg text-sm ${
+                  testResults.embedding.status === "success"
+                    ? "bg-green-50 dark:bg-green-900/20 text-green-700 dark:text-green-300"
+                    : "bg-red-50 dark:bg-red-900/20 text-red-700 dark:text-red-300"
+                }`}>
+                  <strong>Embedding Model:</strong> {testResults.embedding.message}
+                </div>
+              )}
+              
+              {testResults.multimodal && testResults.multimodal.status !== "not_tested" && (
+                <div className={`p-3 rounded-lg text-sm ${
+                  testResults.multimodal.status === "success"
+                    ? "bg-green-50 dark:bg-green-900/20 text-green-700 dark:text-green-300"
+                    : "bg-red-50 dark:bg-red-900/20 text-red-700 dark:text-red-300"
+                }`}>
+                  <strong>Multimodal Model:</strong> {testResults.multimodal.message}
+                </div>
+              )}
+            </div>
+          )}
+
+          {/* Buttons */}
+          <div className="flex gap-3">
+            {!isChatbotOnlyMode && (
+              <Button
+                onClick={handleTestConnection}
+                disabled={isTesting || isSaving}
+                className="flex-1 bg-blue-600 hover:bg-blue-700 text-white"
+              >
+                <CheckCircle2 className="h-4 w-4 mr-2" />
+                {isTesting ? "Testing..." : "Test Connection"}
+              </Button>
+            )}
+
+            <Button 
+              onClick={handleSave} 
+              disabled={isSaving || isTesting || (!isChatbotOnlyMode && !connectionTested)}
+              className="gradient text-white flex-1"
+            >
+              {isSaving ? (
+                <>
+                  <Loader2 className="h-4 w-4 mr-2 animate-spin" />
+                  Saving...
+                </>
+              ) : (
+                <>
+                  <Save className="h-4 w-4 mr-2" />
+                  Save Configuration
+                </>
+              )}
+            </Button>
+          </div>
+        </div>
+        </fieldset>
+      </div>
+    </div>
+  );
+};
+
+export default LLMConfig;
diff --git a/graphrag-ui/src/pages/setup/SetupLayout.tsx b/graphrag-ui/src/pages/setup/SetupLayout.tsx
new file mode 100644
index 0000000..3907609
--- /dev/null
+++ b/graphrag-ui/src/pages/setup/SetupLayout.tsx
@@ -0,0 +1,216 @@
+import React from "react";
+import { Outlet, useNavigate, useLocation } from "react-router-dom";
+import { Button } from "@/components/ui/button";
+import { ArrowLeft, Database, Settings, FileText, ChevronRight } from "lucide-react";
+import { cn } from "@/lib/utils";
+import { useRoles } from "@/hooks/useRoles";
+
+const SetupLayout = () => {
+  const navigate = useNavigate();
+  const location = useLocation();
+  const {
+    rolesLoaded,
+    hasCreds,
+    isSuperuser,
+    isGlobalDesigner,
+    isGraphAdmin,
+    canAccessSetup,
+  } = useRoles(location.pathname);
+  const canAccessPrompts = canAccessSetup;
+  const canAccessLlmConfig = canAccessSetup;
+
+  const menuItems = [
+    {
+      title: "Knowledge Graph Setup",
+      icon: Database,
+      path: "/setup/kg-admin",
+      subItems: [],
+    },
+    {
+      title: "Server Configuration",
+      icon: Settings,
+      path: "/setup/server-config",
+      subItems: [
+        ...(isSuperuser ? [{ title: "Graph Database Config", path: "/setup/server-config/graphdb" }] : []),
+        ...(isSuperuser || isGlobalDesigner ? [{ title: "GraphRAG Config", path: "/setup/server-config/graphrag" }] : []),
+        ...(canAccessLlmConfig ? [{ title: "LLM Config", path: "/setup/server-config/llm" }] : []),
+      ],
+    },
+    {
+      title: "Customize Prompts",
+      icon: FileText,
+      path: "/setup/prompts",
+      subItems: [],
+    },
+  ];
+
+  const visibleMenuItems = menuItems.filter((item) => {
+    if (!isSuperuser && !isGlobalDesigner) {
+      if (item.path === "/setup/prompts") return canAccessPrompts;
+      if (item.path === "/setup/server-config") return canAccessLlmConfig;
+      return false;
+    }
+    return item.path !== "/setup/prompts" || canAccessPrompts;
+  });
+
+  const [expandedSection, setExpandedSection] = React.useState<string>("");
+
+  React.useEffect(() => {
+    const currentSection = menuItems.find(
+      (item) => location.pathname.startsWith(item.path)
+    );
+    if (currentSection) {
+      setExpandedSection(currentSection.path);
+    }
+  }, [location.pathname]);
+
+  React.useEffect(() => {
+    if (rolesLoaded && (!hasCreds || !canAccessSetup)) {
+      navigate("/", { replace: true });
+    }
+    if (
+      rolesLoaded &&
+      isGraphAdmin &&
+      !isSuperuser &&
+      !isGlobalDesigner &&
+      !location.pathname.startsWith("/setup/prompts") &&
+      !location.pathname.startsWith("/setup/server-config/llm")
+    ) {
+      navigate("/setup/server-config/llm", { replace: true });
+    }
+    if (
+      rolesLoaded &&
+      !isSuperuser &&
+      location.pathname.startsWith("/setup/server-config/graphdb")
+    ) {
+      navigate("/setup/server-config/llm", { replace: true });
+    }
+    if (
+      rolesLoaded &&
+      !isSuperuser &&
+      !isGlobalDesigner &&
+      location.pathname.startsWith("/setup/server-config/graphrag")
+    ) {
+      navigate("/setup/server-config/llm", { replace: true });
+    }
+  }, [
+    rolesLoaded,
+    hasCreds,
+    canAccessSetup,
+    isGraphAdmin,
+    isSuperuser,
+    isGlobalDesigner,
+    canAccessLlmConfig,
+    location.pathname,
+    navigate,
+  ]);
+
+  const isActive = (path: string) => {
+    return location.pathname === path;
+  };
+
+  const isParentActive = (path: string) => {
+    return location.pathname.startsWith(path);
+  };
+
+  if (rolesLoaded && (!hasCreds || !canAccessSetup)) {
+    return null;
+  }
+
+  return (
+    <div className="flex h-screen bg-white dark:bg-background">
+      {/* Sidebar */}
+      <div className="w-72 border-r border-gray-300 dark:border-[#3D3D3D] flex flex-col">
+        <div className="p-6 border-b border-gray-300 dark:border-[#3D3D3D]">
+          <Button
+            variant="outline"
+            onClick={() => navigate("/chat")}
+            className="mb-4 w-full dark:border-[#3D3D3D]"
+          >
+            <ArrowLeft className="h-4 w-4 mr-2" />
+            Back to Chat
+          </Button>
+          <h1 className="text-xl font-bold text-black dark:text-white">
+            Setup & Configuration
+          </h1>
+          <p className="text-xs text-gray-600 dark:text-[#D9D9D9] mt-1">
+            Manage your system settings
+          </p>
+        </div>
+
+        {/* Navigation Menu */}
+        <nav className="flex-1 overflow-y-auto p-4">
+          <div className="space-y-2">
+            {visibleMenuItems.map((item) => {
+              const Icon = item.icon;
+              const hasSubItems = item.subItems.length > 0;
+              const isExpanded = expandedSection === item.path;
+              const isItemActive = isParentActive(item.path);
+
+              return (
+                <div key={item.path}>
+                  <button
+                    onClick={() => {
+                      if (hasSubItems) {
+                        setExpandedSection(isExpanded ? "" : item.path);
+                      } else {
+                        navigate(item.path);
+                      }
+                    }}
+                    className={cn(
+                      "w-full flex items-center justify-between px-3 py-2.5 rounded-lg text-sm font-medium transition-colors",
+                      isItemActive
+                        ? "bg-tigerOrange/10 text-tigerOrange"
+                        : "text-gray-700 dark:text-gray-300 hover:bg-gray-100 dark:hover:bg-[#2A2A2A]"
+                    )}
+                  >
+                    <div className="flex items-center gap-3">
+                      <Icon className="h-4 w-4" />
+                      <span>{item.title}</span>
+                    </div>
+                    {hasSubItems && (
+                      <ChevronRight
+                        className={cn(
+                          "h-4 w-4 transition-transform",
+                          isExpanded && "rotate-90"
+                        )}
+                      />
+                    )}
+                  </button>
+
+                  {/* Sub-items */}
+                  {hasSubItems && isExpanded && (
+                    <div className="ml-7 mt-1 space-y-1">
+                      {item.subItems.map((subItem) => (
+                        <button
+                          key={subItem.path}
+                          onClick={() => navigate(subItem.path)}
+                          className={cn(
+                            "w-full text-left px-3 py-2 rounded-lg text-sm transition-colors",
+                            isActive(subItem.path)
+                              ? "bg-tigerOrange/10 text-tigerOrange font-medium"
+                              : "text-gray-600 dark:text-gray-400 hover:bg-gray-100 dark:hover:bg-[#2A2A2A]"
+                          )}
+                        >
+                          {subItem.title}
+                        </button>
+                      ))}
+                    </div>
+                  )}
+                </div>
+              );
+            })}
+          </div>
+        </nav>
+      </div>
+
+      {/* Main Content Area */}
+      <div className="flex-1 overflow-y-auto">
+        <Outlet />
+      </div>
+    </div>
+  );
+};
+
+export default SetupLayout;
+
diff --git a/graphrag/app/agent/agent.py b/graphrag/app/agent/agent.py
index 1ecb3b8..49b8552 100644
--- a/graphrag/app/agent/agent.py
+++ b/graphrag/app/agent/agent.py
@@ -8,21 +8,9 @@
 from fastapi import WebSocket
 from tools import GenerateCypher, GenerateFunction, MapQuestionToSchema
 
-from common.config import embedding_service, embedding_store, llm_config
+from common.config import embedding_service, embedding_store, llm_config, get_completion_config, get_chat_config, get_llm_service
 from common.embeddings.base_embedding_store import EmbeddingStore
 from common.embeddings.embedding_services import EmbeddingModel
-from common.llm_services import (
-    AWS_SageMaker_Endpoint,
-    AWSBedrock,
-    AzureOpenAI,
-    GoogleVertexAI,
-    GoogleGenAI,
-    Groq,
-    HuggingFaceEndpoint,
-    Ollama,
-    OpenAI,
-    IBMWatsonX
-)
 from common.llm_services.base_llm import LLM_Model
 from common.logs.log import req_id_cv
 from common.logs.logwriter import LogWriter
@@ -166,47 +154,12 @@ def question_for_agent(
 
 
 def make_agent(graphname, conn, use_cypher, ws: WebSocket = None, supportai_retriever="hybridsearch") -> TigerGraphAgent:
-    if "chat_model" in llm_config["completion_service"]:
-        llm_config["completion_service"]["llm_model"] = llm_config["completion_service"]["chat_model"]
-
-    if llm_config["completion_service"]["llm_service"].lower() == "openai":
-        llm_service_name = "openai"
-        llm_provider = OpenAI(llm_config["completion_service"])
-    elif llm_config["completion_service"]["llm_service"].lower() == "azure":
-        llm_service_name = "azure"
-        llm_provider = AzureOpenAI(llm_config["completion_service"])
-    elif llm_config["completion_service"]["llm_service"].lower() == "sagemaker":
-        llm_service_name = "sagemaker"
-        llm_provider = AWS_SageMaker_Endpoint(llm_config["completion_service"])
-    elif llm_config["completion_service"]["llm_service"].lower() == "vertexai":
-        llm_service_name = "vertexai"
-        llm_provider = GoogleVertexAI(llm_config["completion_service"])
-    elif llm_config["completion_service"]["llm_service"].lower() == "genai":
-        llm_service_name = "genai"
-        llm_provider = GoogleGenAI(llm_config["completion_service"])
-    elif llm_config["completion_service"]["llm_service"].lower() == "bedrock":
-        llm_service_name = "bedrock"
-        llm_provider = AWSBedrock(llm_config["completion_service"])
-    elif llm_config["completion_service"]["llm_service"].lower() == "groq":
-        llm_service_name = "groq"
-        llm_provider = Groq(llm_config["completion_service"])
-    elif llm_config["completion_service"]["llm_service"].lower() == "ollama":
-        llm_service_name = "ollama"
-        llm_provider = Ollama(llm_config["completion_service"])
-    elif llm_config["completion_service"]["llm_service"].lower() == "huggingface":
-        llm_service_name = "huggingface"
-        llm_provider = HuggingFaceEndpoint(llm_config["completion_service"])
-    elif llm_config["completion_service"]["llm_service"].lower() == "watsonx":
-        llm_service_name = "watsonx"
-        llm_provider = IBMWatsonX(llm_config["completion_service"])
-    else:
-        LogWriter.error(
-            f"/{graphname}/query_with_history request_id={req_id_cv.get()} agent creation failed due to invalid llm_service"
-        )
-        raise Exception("LLM Completion Service Not Supported")
+    llm_provider = get_llm_service(get_chat_config(graphname))
+    chat_config = llm_provider.config
 
-    logger.debug(
-        f"/{graphname}/query_with_history request_id={req_id_cv.get()} llm_service={llm_service_name} agent created"
+    logger.info(
+        f"[CHATBOT] graph={graphname} model={chat_config['llm_model']} "
+        f"provider={chat_config['llm_service']} prompt_path={chat_config.get('prompt_path', 'unknown')}"
     )
 
     agent = TigerGraphAgent(
diff --git a/graphrag/app/agent/agent_generation.py b/graphrag/app/agent/agent_generation.py
index 34dd770..d6b3461 100644
--- a/graphrag/app/agent/agent_generation.py
+++ b/graphrag/app/agent/agent_generation.py
@@ -16,13 +16,11 @@
 import logging
 from langchain.prompts import PromptTemplate
 from langchain_core.output_parsers import PydanticOutputParser
-from langchain_community.callbacks.manager import get_openai_callback
 from typing import Optional
 from pydantic import BaseModel, Field
 from common.logs.logwriter import LogWriter
 from common.logs.log import req_id_cv
 from common.utils.token_calculator import get_token_calculator
-from common.config import completion_config
 from common.py_schemas import GraphRAGAnswerOutput
 
 logger = logging.getLogger(__name__)
@@ -30,7 +28,8 @@
 class TigerGraphAgentGenerator:
     def __init__(self, llm_model):
         self.llm = llm_model
-        self.token_calculator = get_token_calculator(token_limit=completion_config.get("token_limit"), model_name=completion_config.get("llm_model"))
+        llm_config = getattr(llm_model, "config", {})
+        self.token_calculator = get_token_calculator(token_limit=llm_config.get("token_limit"), model_name=llm_config.get("llm_model"))
 
     def generate_answer(self, question: str, context: str | dict, query: str = "") -> dict:
         """Generate an answer based on the question and context.
@@ -55,7 +54,6 @@ def generate_answer(self, question: str, context: str | dict, query: str = "") -
                     logger.info(f"Truncated context from {context_tokens} to {max_context_tokens} tokens")
 
         answer_parser = PydanticOutputParser(pydantic_object=GraphRAGAnswerOutput)
-
         prompt = PromptTemplate(
             template=self.llm.chatbot_response_prompt,
             input_variables=["question", "context", "query"],
@@ -64,28 +62,19 @@ def generate_answer(self, question: str, context: str | dict, query: str = "") -
             }
         )
 
-        full_prompt = prompt.format(
-            question=question,
-            context=context,
-            query=query,
-            format_instructions=answer_parser.get_format_instructions()
-        )
-
-        # Chain
-        rag_chain = prompt | self.llm.model | answer_parser
-
         if isinstance(context, dict):
             context = json.dumps(context)
 
-        usage_data = {}
-        with get_openai_callback() as cb:
-            generation = rag_chain.invoke({"question": question, "context": context, "query": query})
+        try:
+            generation = self.llm.invoke_with_parser(
+                prompt, answer_parser,
+                {"question": question, "context": context, "query": query},
+                caller_name="generate_answer",
+            )
+        except Exception:
+            logger.warning("generate_answer: all parsing failed, using raw context as answer")
+            generation = GraphRAGAnswerOutput(generated_answer=str(context).strip(), citation=[])
 
-            usage_data["input_tokens"] = cb.prompt_tokens
-            usage_data["output_tokens"] = cb.completion_tokens
-            usage_data["total_tokens"] = cb.total_tokens
-            usage_data["cost"] = cb.total_cost
-            logger.info(f"generate_answer usage: {usage_data}")
         LogWriter.info(f"request_id={req_id_cv.get()} EXIT generate_answer")
 
         return generation
diff --git a/graphrag/app/agent/agent_graph.py b/graphrag/app/agent/agent_graph.py
index 49ce41b..fc9fc96 100644
--- a/graphrag/app/agent/agent_graph.py
+++ b/graphrag/app/agent/agent_graph.py
@@ -26,6 +26,7 @@
 from agent.agent_usefulness_check import TigerGraphAgentUsefulnessCheck
 from agent.Q import DONE, Q
 from langchain.prompts import PromptTemplate
+from langchain_core.output_parsers import StrOutputParser
 from langgraph.graph import END, StateGraph
 from pyTigerGraph.common.exception import TigerGraphException
 from supportai.retrievers import (HybridRetriever, SimilarityRetriever,
@@ -36,7 +37,7 @@
 from common.logs.log import req_id_cv
 from common.py_schemas import GraphRAGResponse, MapQuestionToSchemaResponse
 from common.llm_services.aws_bedrock_service import AWSBedrock
-from common.config import graphrag_config
+from common.config import get_graphrag_config
 
 logger = logging.getLogger(__name__)
 
@@ -83,6 +84,7 @@ def __init__(
         self.enable_human_in_loop = enable_human_in_loop
         self.q = q
 
+        self._graphrag_cfg = get_graphrag_config(db_connection.graphname)
         self.supportai_enabled = True
         self.supportai_retriever = supportai_retriever.lower().replace(" ", "")
         try:
@@ -102,12 +104,42 @@ def entry(self, state):
             state["question_retry_count"] += 1
         return state
 
+    _GREETING_PATTERNS = re.compile(
+        r"^("
+        r"h(i|ello|ey|owdy|iya)(\s+there)?|"
+        r"yo+|sup|what'?s\s*up|"
+        r"good\s+(morning|afternoon|evening|night|day)|"
+        r"greetings|"
+        r"thanks?(\s+you)?|thank\s+you(\s+so\s+much)?|"
+        r"bye|goodbye|see\s+you|take\s+care"
+        r")$",
+        re.IGNORECASE,
+    )
+
+    def _is_greeting(self, question: str) -> bool:
+        """Check if the question is a simple greeting or non-question."""
+        normalized = question.strip().rstrip("!?.,;")
+        return bool(self._GREETING_PATTERNS.match(normalized))
+
+    def greet(self, state):
+        """Respond to greetings and ask the user to provide a real question."""
+        self.emit_progress(DONE)
+        state["answer"] = GraphRAGResponse(
+            natural_language_response="Hello! I'm your knowledge graph assistant. Please ask a question about your data and I'll do my best to help.",
+            answered_question=False,
+            response_type="greeting",
+            query_sources={},
+        )
+        return state
+
     def route_question(self, state):
         """
         Run the agent router.
         """
         if state["question_retry_count"] > 2:
             return "apologize"
+        if self._is_greeting(state["question"]):
+            return "greeting"
         self.emit_progress("Thinking")
         step = TigerGraphAgentRouter(self.llm_provider, self.db_connection)
         logger.debug_pii(
@@ -161,9 +193,11 @@ def contextualize_question(self, question: str, conversation) -> str:
                 template=self.llm_provider.contextualize_question_prompt,
                 input_variables=["history", "question"],
             )
-            chain = prompt | self.llm_provider.model
-            result = chain.invoke({"history": history_text, "question": question})
-            standalone = result.content.strip() if hasattr(result, "content") else str(result).strip()
+            standalone = self.llm_provider.invoke_with_parser(
+                prompt, StrOutputParser(),
+                {"history": history_text, "question": question},
+                caller_name="contextualize_question",
+            ).strip()
             logger.info(f"Contextualized question for KG search: {standalone}")
             return standalone or question
         except Exception as e:
@@ -270,9 +304,17 @@ def generate_cypher(self, state):
         self.emit_progress("Generating the query to answer your question")
         gen_history = []
         response_json = None
+        cypher = None
+        json_str = None
+        response = None
 
         for i in range(3):
-            cypher = self.cypher_gen._run(state["question"], gen_history)
+            try:
+                cypher = self.cypher_gen._run(state["question"], gen_history)
+            except ValueError as e:
+                logger.warning(f"Cypher generation failed: {e}")
+                gen_history.append(f"{i}: Error: {e}\n")
+                continue
             response = self.db_connection.gsql(cypher)
             response_lines = response.split("\n")
             json_str = "\n".join(response_lines[1:])
@@ -298,7 +340,8 @@ def generate_cypher(self, state):
             if "error_history" not in state or state["error_history"] is None:
                 state["error_history"] = []
             
-            state["error_history"].append({"error_message": response, "error_step": "generate_cypher"})
+            error_msg = response if response else "LLM failed to produce a valid Cypher query after 3 attempts"
+            state["error_history"].append({"error_message": error_msg, "error_step": "generate_cypher"})
 
         state["lookup_source"] = "cypher"
         return state
@@ -311,18 +354,18 @@ def hybrid_search(self, state):
         retriever = HybridRetriever(
             self.embedding_model,
             self.embedding_store,
-            self.llm_provider.model,
+            self.llm_provider,
             self.db_connection,
         )
-        chunk_only=graphrag_config.get("chunk_only", True)
+        chunk_only=self._graphrag_cfg.get("chunk_only", True)
         step = retriever.search(
             state["question"],
             indices=["DocumentChunk"],
-            top_k=graphrag_config.get("top_k", 5),
-            num_seen_min=graphrag_config.get("num_seen_min", 2),
-            num_hops=graphrag_config.get("num_hops", 2),
+            top_k=self._graphrag_cfg.get("top_k", 5),
+            num_seen_min=self._graphrag_cfg.get("num_seen_min", 2),
+            num_hops=self._graphrag_cfg.get("num_hops", 2),
             chunk_only=chunk_only,
-            doc_only=graphrag_config.get("doc_only", False),
+            doc_only=self._graphrag_cfg.get("doc_only", False),
         )
 
         query_name = "GraphRAG_Hybrid_Vector_Search"
@@ -351,7 +394,7 @@ def similarity_search(self, state):
         step = retriever.search(
             state["question"],
             index="DocumentChunk",
-            top_k=graphrag_config.get("top_k", 5)
+            top_k=self._graphrag_cfg.get("top_k", 5)
         )
 
         query_name = "Content_Similarity_Vector_Search"
@@ -373,13 +416,13 @@ def sibling_search(self, state):
         retriever = SiblingRetriever(
             self.embedding_model,
             self.embedding_store,
-            self.llm_provider.model,
+            self.llm_provider,
             self.db_connection,
         )
         step = retriever.search(
             state["question"],
             index="DocumentChunk",
-            top_k=graphrag_config.get("top_k", 5)
+            top_k=self._graphrag_cfg.get("top_k", 5)
         )
 
         query_name = "Chunk_Sibling_Vector_Search"
@@ -401,14 +444,14 @@ def community_search(self, state):
         retriever = CommunityRetriever(
             self.embedding_model,
             self.embedding_store,
-            self.llm_provider.model,
+            self.llm_provider,
             self.db_connection,
         )
         step = retriever.search(
             state["question"],
-            community_level=graphrag_config.get("community_level", 2),
-            top_k=graphrag_config.get("top_k", 5),
-            with_chunk=graphrag_config.get("with_chunk", True),
+            community_level=self._graphrag_cfg.get("community_level", 2),
+            top_k=self._graphrag_cfg.get("top_k", 5),
+            with_chunk=self._graphrag_cfg.get("with_chunk", True),
         )
 
         query_name = "GraphRAG_Community_Vector_Search"
@@ -733,6 +776,7 @@ def create_graph(self):
             self.workflow.add_node("merge_history_context", self.merge_history_context)
         self.workflow.add_node("rewrite_question", self.rewrite_question)
         self.workflow.add_node("apologize", self.apologize)
+        self.workflow.add_node("greet", self.greet)
 
         if self.cypher_gen:
             self.workflow.add_node("generate_cypher", self.generate_cypher)
@@ -821,6 +865,7 @@ def create_graph(self):
                     "supportai_lookup": "supportai",
                     "inquiryai_lookup": "map_question_to_schema",
                     "history_lookup": "lookup_history",
+                    "greeting": "greet",
                     "apologize": "apologize",
                 },
             )
@@ -831,6 +876,7 @@ def create_graph(self):
                 {
                     "inquiryai_lookup": "map_question_to_schema",
                     "history_lookup": "lookup_history",
+                    "greeting": "greet",
                     "apologize": "apologize",
                 },
             )
@@ -851,6 +897,7 @@ def create_graph(self):
         self.workflow.add_edge("map_question_to_schema", "generate_function")
         self.workflow.add_edge("rewrite_question", "entry")
         self.workflow.add_edge("apologize", END)
+        self.workflow.add_edge("greet", END)
 
         app = self.workflow.compile()
         return app
diff --git a/graphrag/app/agent/agent_hallucination_check.py b/graphrag/app/agent/agent_hallucination_check.py
index 6951c4a..c51d2b4 100644
--- a/graphrag/app/agent/agent_hallucination_check.py
+++ b/graphrag/app/agent/agent_hallucination_check.py
@@ -1,7 +1,6 @@
 import logging
 from langchain.prompts import PromptTemplate
 from langchain_core.output_parsers import PydanticOutputParser
-from langchain_community.callbacks.manager import get_openai_callback
 
 from pydantic import BaseModel, Field
 from common.logs.logwriter import LogWriter
@@ -45,17 +44,10 @@ def check_hallucination(self, generation: str, context: str) -> dict:
             }
         )
 
-        # Chain
-        rag_chain = prompt | self.llm.model | hallucination_parser
-
-        usage_data = {}
-        with get_openai_callback() as cb:
-            prediction = rag_chain.invoke({"context": context, "generation": generation})
-
-            usage_data["input_tokens"] = cb.prompt_tokens
-            usage_data["output_tokens"] = cb.completion_tokens
-            usage_data["total_tokens"] = cb.total_tokens
-            usage_data["cost"] = cb.total_cost
-            logger.info(f"check_hallucination usage: {usage_data}")
+        prediction = self.llm.invoke_with_parser(
+            prompt, hallucination_parser,
+            {"context": context, "generation": generation},
+            caller_name="check_hallucination",
+        )
         LogWriter.info(f"request_id={req_id_cv.get()} EXIT check_hallucination")
         return prediction
diff --git a/graphrag/app/agent/agent_rewrite.py b/graphrag/app/agent/agent_rewrite.py
index ae83e54..4feda43 100644
--- a/graphrag/app/agent/agent_rewrite.py
+++ b/graphrag/app/agent/agent_rewrite.py
@@ -2,7 +2,6 @@
 import logging
 from langchain.prompts import PromptTemplate
 from langchain_core.output_parsers import PydanticOutputParser
-from langchain_community.callbacks.manager import get_openai_callback
 
 from pydantic import BaseModel, Field
 from common.logs.log import req_id_cv
@@ -42,17 +41,9 @@ def rewrite_question(self, question: str) -> str:
         )
 
 
-        # Chain
-        question_rewriter = re_write_prompt | self.llm.model | rewrite_parser
-
-        usage_data = {}
-        with get_openai_callback() as cb:
-            generation = question_rewriter.invoke({"question": question})
-
-            usage_data["input_tokens"] = cb.prompt_tokens
-            usage_data["output_tokens"] = cb.completion_tokens
-            usage_data["total_tokens"] = cb.total_tokens
-            usage_data["cost"] = cb.total_cost
-            logger.info(f"rewrite_question usage: {usage_data}")
+        generation = self.llm.invoke_with_parser(
+            re_write_prompt, rewrite_parser,
+            {"question": question}, caller_name="rewrite_question",
+        )
         LogWriter.info(f"request_id={req_id_cv.get()} EXIT rewrite_question")
         return generation.rewritten_question
diff --git a/graphrag/app/agent/agent_router.py b/graphrag/app/agent/agent_router.py
index 1e97470..7668727 100644
--- a/graphrag/app/agent/agent_router.py
+++ b/graphrag/app/agent/agent_router.py
@@ -14,7 +14,6 @@
 
 from langchain.prompts import PromptTemplate
 from langchain_core.output_parsers import PydanticOutputParser
-from langchain_community.callbacks.manager import get_openai_callback
 
 from pydantic import BaseModel, Field
 from common.logs.logwriter import LogWriter
@@ -55,15 +54,10 @@ def route_question(self, question: str, conversation: list[dict[str, str]] = Non
             }
         )
 
-        question_router = prompt | self.llm.model | router_parser
-        usage_data = {}
-        with get_openai_callback() as cb:
-            res = question_router.invoke({"question": question, "v_types": v_types, "e_types": e_types, "conversation": conversation})
-
-            usage_data["input_tokens"] = cb.prompt_tokens
-            usage_data["output_tokens"] = cb.completion_tokens
-            usage_data["total_tokens"] = cb.total_tokens
-            usage_data["cost"] = cb.total_cost
-            logger.info(f"route_question usage: {usage_data}")
+        res = self.llm.invoke_with_parser(
+            prompt, router_parser,
+            {"question": question, "v_types": v_types, "e_types": e_types, "conversation": conversation},
+            caller_name="route_question",
+        )
         LogWriter.info(f"request_id={req_id_cv.get()} EXIT route_question with {res}")
         return res
diff --git a/graphrag/app/agent/agent_usefulness_check.py b/graphrag/app/agent/agent_usefulness_check.py
index 425fc84..fe836f9 100644
--- a/graphrag/app/agent/agent_usefulness_check.py
+++ b/graphrag/app/agent/agent_usefulness_check.py
@@ -1,6 +1,5 @@
 from langchain.prompts import PromptTemplate
 from langchain_core.output_parsers import PydanticOutputParser
-from langchain_community.callbacks.manager import get_openai_callback
 
 from pydantic import BaseModel, Field
 from common.logs.logwriter import LogWriter
@@ -45,17 +44,10 @@ def check_usefulness(self, question: str, answer: str) -> dict:
             }
         )
 
-        # Chain
-        rag_chain = prompt | self.llm.model | usefulness_parser
-
-        usage_data = {}
-        with get_openai_callback() as cb:
-            prediction = rag_chain.invoke({"generation": answer, "question": question})
-
-            usage_data["input_tokens"] = cb.prompt_tokens
-            usage_data["output_tokens"] = cb.completion_tokens
-            usage_data["total_tokens"] = cb.total_tokens
-            usage_data["cost"] = cb.total_cost
-            logger.info(f"check_usefulness usage: {usage_data}")
+        prediction = self.llm.invoke_with_parser(
+            prompt, usefulness_parser,
+            {"generation": answer, "question": question},
+            caller_name="check_usefulness",
+        )
         LogWriter.info(f"request_id={req_id_cv.get()} EXIT check_usefulness")
         return prediction
diff --git a/graphrag/app/routers/queryai.py b/graphrag/app/routers/queryai.py
index f5f2794..d187922 100644
--- a/graphrag/app/routers/queryai.py
+++ b/graphrag/app/routers/queryai.py
@@ -5,7 +5,7 @@
 from fastapi import APIRouter, Request, Depends
 from fastapi.security.http import HTTPBase
 
-from common.config import get_llm_service, llm_config
+from common.config import get_chat_config, get_llm_service
 from common.logs.log import req_id_cv
 from common.py_schemas.schemas import (
     GraphRAGResponse,
@@ -34,7 +34,7 @@ def generate_cypher(
         f"/{graphname}/generate_cypher request_id={req_id_cv.get()} database connection created"
     )
 
-    llm = get_llm_service(llm_config)
+    llm = get_llm_service(get_chat_config(graphname))
 
     cypher_gen_tool = GenerateCypher(conn, llm)
 
diff --git a/graphrag/app/routers/supportai.py b/graphrag/app/routers/supportai.py
index c5a3c66..dac8db8 100644
--- a/graphrag/app/routers/supportai.py
+++ b/graphrag/app/routers/supportai.py
@@ -32,8 +32,8 @@
     graphrag_config,
     embedding_service,
     embedding_store,
+    get_chat_config,
     get_llm_service,
-    llm_config,
     service_status,
 )
 from common.logs.logwriter import LogWriter
@@ -119,7 +119,7 @@ def search(
         query.method_params["verbose"] = False
     if query.method.lower() == "hybrid":
         retriever = HybridRetriever(
-            embedding_service, embedding_store, get_llm_service(llm_config), conn
+            embedding_service, embedding_store, get_llm_service(get_chat_config(graphname)), conn
         )
         if "method" not in query.method_params:
             query.method_params["method"] = "similarity"
@@ -146,7 +146,7 @@ def search(
         if "index" not in query.method_params:
             raise Exception("Index name not provided")
         retriever = SimilarityRetriever(
-            embedding_service, embedding_store, get_llm_service(llm_config), conn
+            embedding_service, embedding_store, get_llm_service(get_chat_config(graphname)), conn
         )
         res = retriever.search(
             query.question,
@@ -160,7 +160,7 @@ def search(
         if "index" not in query.method_params:
             raise Exception("Index name not provided")
         retriever = SiblingRetriever(
-            embedding_service, embedding_store, get_llm_service(llm_config), conn
+            embedding_service, embedding_store, get_llm_service(get_chat_config(graphname)), conn
         )
         res = retriever.search(
             query.question,
@@ -174,12 +174,12 @@ def search(
         )
     elif query.method.lower() == "entityrelationship":
         retriever = EntityRelationshipRetriever(
-            embedding_service, embedding_store, get_llm_service(llm_config), conn
+            embedding_service, embedding_store, get_llm_service(get_chat_config(graphname)), conn
         )
         res = retriever.search(query.question, query.method_params["top_k"])
     elif query.method.lower() == "community":
         retriever = CommunityRetriever(
-            embedding_service, embedding_store, get_llm_service(llm_config), conn
+            embedding_service, embedding_store, get_llm_service(get_chat_config(graphname)), conn
         )
         if "with_chunk" not in query.method_params:
             query.method_params["with_chunk"] = True
@@ -222,7 +222,7 @@ def answer_question(
         query.method_params["verbose"] = False
     if query.method.lower() == "hybrid":
         retriever = HybridRetriever(
-            embedding_service, embedding_store, get_llm_service(llm_config), conn
+            embedding_service, embedding_store, get_llm_service(get_chat_config(graphname)), conn
         )
         if "method" not in query.method_params:
             query.method_params["method"] = "Similarity"
@@ -250,7 +250,7 @@ def answer_question(
         if "index" not in query.method_params:
             raise Exception("Index name not provided")
         retriever = SimilarityRetriever(
-            embedding_service, embedding_store, get_llm_service(llm_config), conn
+            embedding_service, embedding_store, get_llm_service(get_chat_config(graphname)), conn
         )
         res = retriever.retrieve_answer(
             query.question,
@@ -265,7 +265,7 @@ def answer_question(
         if "index" not in query.method_params:
             raise Exception("Index name not provided")
         retriever = SiblingRetriever(
-            embedding_service, embedding_store, get_llm_service(llm_config), conn
+            embedding_service, embedding_store, get_llm_service(get_chat_config(graphname)), conn
         )
         res = retriever.retrieve_answer(
             query.question,
@@ -280,13 +280,13 @@ def answer_question(
         )
     elif query.method.lower() == "entityrelationship":
         retriever = EntityRelationshipRetriever(
-            embedding_service, embedding_store, get_llm_service(llm_config), conn
+            embedding_service, embedding_store, get_llm_service(get_chat_config(graphname)), conn
         )
         res = retriever.retrieve_answer(query.question, query.method_params["top_k"])
 
     elif query.method.lower() == "community":
         retriever = CommunityRetriever(
-            embedding_service, embedding_store, get_llm_service(llm_config), conn
+            embedding_service, embedding_store, get_llm_service(get_chat_config(graphname)), conn
         )
         if "with_chunk" not in query.method_params:
             query.method_params["with_chunk"] = True
@@ -330,7 +330,7 @@ def graphrag_update(
     from httpx import get as http_get
 
     ecc = (
-        graphrag_config.get("ecc", "http://localhost:8001")
+        graphrag_config.get("ecc", "http://graphrag-ecc:8001")
         + f"/{graphname}/{method}/consistency_update"
     )
     LogWriter.info(f"Sending ECC request to: {ecc}")
diff --git a/graphrag/app/routers/ui.py b/graphrag/app/routers/ui.py
index 0fc1473..9bd22b8 100644
--- a/graphrag/app/routers/ui.py
+++ b/graphrag/app/routers/ui.py
@@ -14,10 +14,14 @@
 
 import asyncio
 import base64
+import copy
+import hashlib
 import json
 import logging
 import os
 import re
+import shutil
+import threading
 import time
 import traceback
 import uuid
@@ -35,6 +39,7 @@
     Depends,
     File,
     HTTPException,
+    Path,
     Request,
     UploadFile,
     WebSocket,
@@ -46,7 +51,7 @@
 from pyTigerGraph import TigerGraphConnection
 from tools.validation_utils import MapQuestionToSchemaException
 
-from common.config import db_config, graphrag_config, embedding_service, llm_config, service_status
+from common.config import db_config, graphrag_config, embedding_service, llm_config, service_status, SERVER_CONFIG, get_chat_config, validate_graphname
 from common.db.connections import get_db_connection_pwd_manual
 from common.logs.log import req_id_cv
 from common.logs.logwriter import LogWriter
@@ -65,11 +70,204 @@
 
 logger = logging.getLogger(__name__)
 
+# Validated graph name path parameter — rejects path traversal characters
+ValidGraphName = Annotated[str, Path(pattern=r"^[A-Za-z_][A-Za-z0-9_]*$")]
+
 use_cypher = os.getenv("USE_CYPHER", "false").lower() == "true"
 route_prefix = "/ui"  # APIRouter's prefix doesn't work with the websocket, so it has to be done here
 router = APIRouter(tags=["UI"])
 security = HTTPBasic()
 GRAPH_NAME_RE = re.compile(r"- Graph (.*)\(")
+llm_config_lock = asyncio.Lock()
+
+# Cache for user role lookups (avoids repeated GSQL calls)
+# Key: (username, password_hash) -> (timestamp, (global_roles, graph_roles))
+_role_cache: dict[tuple[str, str], tuple[float, tuple[list[str], dict[str, list[str]]]]] = {}
+_role_cache_lock = threading.Lock()
+_ROLE_CACHE_TTL = 60  # seconds
+
+def _normalize_roles(raw_roles: str) -> list[str]:
+    cleaned = re.sub(r"[\[\]]", "", raw_roles).strip()
+    if not cleaned or cleaned.lower() == "none":
+        return []
+    return [r.strip().lower() for r in re.split(r"[,\s]+", cleaned) if r.strip()]
+
+
+def _parse_user_roles_detail(user_info: str, username: str) -> tuple[list[str], dict[str, list[str]]]:
+    global_roles: list[str] = []
+    graph_roles: dict[str, list[str]] = {}
+    is_user_section = False
+    for line in user_info.splitlines():
+        line_stripped = line.strip()
+        match = re.match(
+            r"^[\*\-]?\s*\-?\s*(Name|User Name|User)\s*:\s*(.+)$",
+            line_stripped,
+            re.IGNORECASE,
+        )
+        if match:
+            current_name = match.group(2).strip()
+            is_user_section = current_name == username
+            continue
+        if not is_user_section:
+            continue
+
+        roles_match = re.match(
+            r"^[\*\-]?\s*\-?\s*(Global Roles|Roles)\s*:\s*(.+)$",
+            line_stripped,
+            re.IGNORECASE,
+        )
+        if roles_match:
+            global_roles.extend(_normalize_roles(roles_match.group(2)))
+            continue
+
+        graph_roles_match = re.match(
+            r"^[\*\-]?\s*\-?\s*Graph\s+'([^']+)'\s+Roles\s*:\s*(.+)$",
+            line_stripped,
+            re.IGNORECASE,
+        )
+        if graph_roles_match:
+            graph_name = graph_roles_match.group(1).strip()
+            roles = _normalize_roles(graph_roles_match.group(2))
+            if roles:
+                graph_roles[graph_name] = roles
+
+    return global_roles, graph_roles
+
+
+def _parse_user_roles(user_info: str, username: str) -> list[str]:
+    global_roles, _ = _parse_user_roles_detail(user_info, username)
+    return global_roles
+
+def _get_user_role_details(username: str, password: str) -> tuple[list[str], dict[str, list[str]]]:
+    """Get user roles with short TTL cache to avoid repeated GSQL calls."""
+    pwd_hash = hashlib.sha256(password.encode()).hexdigest()[:16]
+    cache_key = (username, pwd_hash)
+    now = time.time()
+
+    with _role_cache_lock:
+        cached = _role_cache.get(cache_key)
+        if cached and (now - cached[0]) < _ROLE_CACHE_TTL:
+            return cached[1]
+
+    conn = TigerGraphConnection(
+        host=db_config.get("hostname"),
+        username=username,
+        password=password,
+        gsPort=db_config.get("gsPort"),
+        restppPort=db_config.get("restppPort"),
+        graphname="",
+    )
+    user_info = conn.gsql("SHOW USER")
+    result = _parse_user_roles_detail(user_info, username)
+
+    with _role_cache_lock:
+        _role_cache[cache_key] = (now, result)
+
+    return result
+
+
+def _get_user_roles(username: str, password: str) -> list[str]:
+    global_roles, _ = _get_user_role_details(username, password)
+    return global_roles
+
+def _require_roles(credentials: HTTPBasicCredentials, allowed_roles: set[str]) -> list[str]:
+    try:
+        roles = _get_user_roles(credentials.username, credentials.password)
+    except Exception as e:
+        logger.error(f"Failed to resolve user roles: {e}")
+        raise HTTPException(status_code=403, detail="Unable to verify user roles.")
+    if not any(role in allowed_roles for role in roles):
+        raise HTTPException(status_code=403, detail="Insufficient permissions.")
+    return roles
+
+
+def _create_llm_service(provider: str, config: dict):
+    """Instantiate an LLM provider, returning None for unsupported providers."""
+    try:
+        return get_llm_service(config)
+    except Exception:
+        return None
+
+
+def _create_embedding_service(provider: str, config: dict):
+    from common.embeddings.embedding_services import (
+        OpenAI_Embedding, AzureOpenAI_Ada002, GenAI_Embedding,
+        VertexAI_PaLM_Embedding, AWS_Bedrock_Embedding, Ollama_Embedding
+    )
+    providers = {
+        "openai": OpenAI_Embedding,
+        "azure": AzureOpenAI_Ada002,
+        "genai": GenAI_Embedding,
+        "vertexai": VertexAI_PaLM_Embedding,
+        "bedrock": AWS_Bedrock_Embedding,
+        "ollama": Ollama_Embedding,
+    }
+    cls = providers.get(provider.lower())
+    return cls(config) if cls else None
+
+
+def _require_prompt_access(credentials: HTTPBasicCredentials, graphname: str | None) -> str:
+    """
+    Check if user can access prompts. Returns access level: 'full' or 'chatbot_only'.
+    Raises 403 for globalobserver or any user without sufficient access.
+    - superuser / globaldesigner  → 'full'   (can edit all prompts)
+    - graph admin on graphname    → 'chatbot_only'  (can only edit chatbot_response)
+    """
+    if graphname:
+        validate_graphname(graphname)
+    try:
+        global_roles, graph_roles = _get_user_role_details(credentials.username, credentials.password)
+    except Exception as e:
+        logger.error(f"Failed to resolve user roles: {e}")
+        raise HTTPException(status_code=403, detail="Unable to verify user roles.")
+    if any(role in {"superuser", "globaldesigner"} for role in global_roles):
+        return "full"
+    if graphname and any(role in {"admin"} for role in graph_roles.get(graphname, [])):
+        return "chatbot_only"
+    raise HTTPException(status_code=403, detail="Insufficient permissions.")
+
+
+def _resolve_llm_config_access(
+    credentials: HTTPBasicCredentials, graphname: str | None
+) -> str:
+    if graphname:
+        validate_graphname(graphname)
+    try:
+        global_roles, graph_roles = _get_user_role_details(
+            credentials.username, credentials.password
+        )
+    except Exception as e:
+        logger.error(f"Failed to resolve user roles: {e}")
+        raise HTTPException(status_code=403, detail="Unable to verify user roles.")
+
+    if any(role in {"superuser", "globaldesigner"} for role in global_roles):
+        return "full"
+    if graphname:
+        roles_for_graph = graph_roles.get(graphname, [])
+        if any(role in {"admin"} for role in roles_for_graph):
+            return "chatbot_only"
+    raise HTTPException(status_code=403, detail="Insufficient permissions.")
+
+def _ecc_jobs_running(graphs: list[str], auth_header: str) -> bool:
+    if not graphs:
+        return False
+    ecc_base = graphrag_config.get("ecc", "http://graphrag-ecc:8001")
+    for graphname in graphs:
+        try:
+            status_url = f"{ecc_base}/{graphname}/graphrag/rebuild_status"
+            response = httpx.get(
+                status_url,
+                headers={"Authorization": auth_header},
+                timeout=5.0,
+            )
+            if response.status_code == 200:
+                payload = response.json()
+                if payload.get("is_running"):
+                    return True
+        except Exception as e:
+            logger.warning(f"ECC status check failed for {graphname}: {e}")
+            continue
+    return False
 
 
 def auth(usr: str, password: str, conn=None) -> tuple[list[str], TigerGraphConnection]:
@@ -119,7 +317,14 @@ def ui_basic_auth(
 @router.post(f"{route_prefix}/ui-login")
 def login(auth: Annotated[list[str], Depends(ui_basic_auth)]):
     graphs = auth[0]
-    return {"graphs": graphs}
+    creds = auth[1]
+    # Fetch roles at login so frontend doesn't need separate /roles calls
+    try:
+        global_roles, graph_roles = _get_user_role_details(creds.username, creds.password)
+    except Exception as e:
+        logger.warning(f"Failed to fetch roles at login: {e}")
+        global_roles, graph_roles = [], {}
+    return {"graphs": graphs, "roles": global_roles, "graph_roles": graph_roles}
 
 
 @router.post(f"{route_prefix}/feedback")
@@ -148,7 +353,7 @@ def add_feedback(
 
 @router.post(route_prefix + "/{graphname}/create_graph")
 def create_graph(
-    graphname: str,
+    graphname: ValidGraphName,
     creds: Annotated[tuple[list[str], HTTPBasicCredentials], Depends(ui_basic_auth)],
 ):
     """
@@ -193,7 +398,7 @@ def create_graph(
 
 @router.post(route_prefix + "/{graphname}/initialize_graph")
 def init_graph(
-    graphname: str,
+    graphname: ValidGraphName,
     creds: Annotated[tuple[list[str], HTTPBasicCredentials], Depends(ui_basic_auth)],
 ):
     """
@@ -235,7 +440,7 @@ def init_graph(
 
 @router.post(route_prefix + "/{graphname}/rebuild_graph")
 async def forceupdate(
-    graphname: str,
+    graphname: ValidGraphName,
     creds: Annotated[tuple[list[str], HTTPBasicCredentials], Depends(ui_basic_auth)],
     bg_tasks: BackgroundTasks,
 ):
@@ -271,7 +476,7 @@ async def forceupdate(
     creds = creds[1]
     auth = base64.b64encode(f"{creds.username}:{creds.password}".encode()).decode()
 
-    ecc_base = graphrag_config.get("ecc", "http://localhost:8001")
+    ecc_base = graphrag_config.get("ecc", "http://graphrag-ecc:8001")
     ecc_update_url = f"{ecc_base}/{graphname}/graphrag/consistency_update"
     ecc_status_url = f"{ecc_base}/{graphname}/graphrag/rebuild_status"
     
@@ -343,7 +548,7 @@ async def rebuild_and_monitor():
 
 @router.get(route_prefix + "/{graphname}/rebuild_status")
 def get_rebuild_status(
-    graphname: str,
+    graphname: ValidGraphName,
     creds: Annotated[tuple[list[str], HTTPBasicCredentials], Depends(ui_basic_auth)],
 ):
     """
@@ -357,7 +562,7 @@ def get_rebuild_status(
 
     try:
         ecc_status_url = (
-            graphrag_config.get("ecc", "http://localhost:8001")
+            graphrag_config.get("ecc", "http://graphrag-ecc:8001")
             + f"/{graphname}/graphrag/rebuild_status"
         )
         LogWriter.info(f"Checking ECC status at: {ecc_status_url}")
@@ -365,7 +570,7 @@ def get_rebuild_status(
         response = httpx.get(
             ecc_status_url,
             headers={"Authorization": f"Basic {auth}"},
-            timeout=10.0
+            timeout=30.0
         )
         
         if response.status_code == 200:
@@ -378,6 +583,15 @@ def get_rebuild_status(
                 "status": "unknown",
                 "error": f"ECC service returned status {response.status_code}"
             }
+    except httpx.TimeoutException as e:
+        # ECC is busy (heavy processing) - assume rebuild is still running
+        LogWriter.warning(f"ECC status check timed out (ECC may be busy): {str(e)}")
+        return {
+            "graphname": graphname,
+            "is_running": True,
+            "status": "unknown",
+            "error": "ECC is busy processing, status check timed out. Rebuild likely still in progress."
+        }
     except Exception as e:
         LogWriter.error(f"Failed to check ECC status: {str(e)}")
         return {
@@ -390,7 +604,7 @@ def get_rebuild_status(
 
 @router.post(route_prefix + "/{graphname}/create_ingest")
 def create_ingest(
-    graphname: str,
+    graphname: ValidGraphName,
     cfg: CreateIngestConfig,
     creds: Annotated[tuple[list[str], HTTPBasicCredentials], Depends(ui_basic_auth)],
 ):
@@ -440,7 +654,7 @@ def create_ingest(
 
 @router.post(route_prefix + "/{graphname}/ingest")
 def ingest(
-    graphname: str,
+    graphname: ValidGraphName,
     loader_info: LoadingInfo,
     creds: Annotated[tuple[list[str], HTTPBasicCredentials], Depends(ui_basic_auth)],
 ):
@@ -490,7 +704,7 @@ def ingest(
 
 @router.get(route_prefix + "/image_vertex/{graphname}/{image_id}")
 async def serve_image_from_vertex(
-    graphname: str,
+    graphname: ValidGraphName,
     image_id: str,
     creds: Annotated[tuple[list[str], HTTPBasicCredentials], Depends(ui_basic_auth)],
 ):
@@ -573,6 +787,16 @@ async def get_user_conversations(
     return res.json()
 
 
+@router.get(route_prefix + "/roles")
+async def get_user_roles(
+    credentials: Annotated[HTTPBasicCredentials, Depends(security)]
+):
+    roles, graph_roles = _get_user_role_details(
+        credentials.username, credentials.password
+    )
+    return {"roles": roles, "graph_roles": graph_roles}
+
+
 @router.get(route_prefix + "/conversation/{conversation_id}")
 async def get_conversation_contents(
     conversation_id: str,
@@ -800,7 +1024,7 @@ async def write_message_to_history(message: Message, usr_auth: str):
 
 @router.get(route_prefix + "/{graphname}/query")
 async def graph_query(
-    graphname: str,
+    graphname: ValidGraphName,
     creds: Annotated[tuple[list[str], HTTPBasicCredentials], Depends(ui_basic_auth)],
     q: str | None = None,
     rag_pattern: str | None = None,
@@ -834,7 +1058,7 @@ async def graph_query(
             conversation_id=convo_id,
             message_id=str(uuid.uuid4()),
             parent_id=prev_id,
-            model=llm_config["model_name"],
+            model=get_chat_config(graphname).get("llm_model", "unknown"),
             content=data,
             role=Role.USER,
         )
@@ -854,7 +1078,7 @@ async def graph_query(
             conversation_id=convo_id,
             message_id=str(uuid.uuid4()),
             parent_id=prev_id,
-            model=llm_config["model_name"],
+            model=get_chat_config(graphname).get("llm_model", "unknown"),
             content=resp.natural_language_response,
             role=Role.SYSTEM,
             response_time=elapsed,
@@ -876,7 +1100,7 @@ async def graph_query(
 
 @router.websocket(route_prefix + "/{graphname}/chat")
 async def chat(
-    graphname: str,
+    graphname: ValidGraphName,
     websocket: WebSocket,
     rag_pattern: str | None = None,
 ):
@@ -918,6 +1142,10 @@ async def chat(
     
     # Get conversation ID
     conversation_id = await websocket.receive_text()
+    logger.info(
+        f"WebSocket conversation_id received: {conversation_id or 'empty'} "
+        f"(graph={graphname}, rag_pattern={rag_pattern})"
+    )
     
     # Load conversation history if not a new conversation
     conversation_history = await load_conversation_history(conversation_id, usr_auth)
@@ -946,7 +1174,7 @@ async def chat(
                 conversation_id=convo_id,
                 message_id=str(uuid.uuid4()),
                 parent_id=prev_id,
-                model=llm_config["model_name"],
+                model=get_chat_config(graphname).get("llm_model", "unknown"),
                 content=data,
                 role=Role.USER,
             )
@@ -966,7 +1194,7 @@ async def chat(
                 conversation_id=convo_id,
                 message_id=str(uuid.uuid4()),
                 parent_id=prev_id,
-                model=llm_config["model_name"],
+                model=get_chat_config(graphname).get("llm_model", "unknown"),
                 content=resp.natural_language_response,
                 role=Role.SYSTEM,
                 response_time=elapsed,
@@ -985,8 +1213,16 @@ async def chat(
                 {"query": data, "response": resp.natural_language_response}
             )
     except WebSocketDisconnect as e:
-        logger.info(f"Websocket disconnected: {str(e)}")
-    except:
+        close_code = getattr(e, "code", None)
+        close_reason = getattr(e, "reason", None)
+        logger.info(
+            f"Websocket disconnected (code={close_code}, reason={close_reason})"
+        )
+    except Exception as e:
+        exc = traceback.format_exc()
+        logger.error(
+            f"Websocket error (graph={graphname}, conversation_id={convo_id}): {e}\n{exc}"
+        )
         await websocket.close()
 
 
@@ -996,7 +1232,7 @@ async def chat(
 
 @router.get(route_prefix + "/{graphname}/uploads/list")
 async def list_uploaded_files(
-    graphname: str,
+    graphname: ValidGraphName,
     creds: Annotated[tuple[list[str], HTTPBasicCredentials], Depends(ui_basic_auth)],
 ):
     """
@@ -1037,7 +1273,7 @@ async def list_uploaded_files(
 
 @router.post(route_prefix + "/{graphname}/uploads")
 async def upload_files(
-    graphname: str,
+    graphname: ValidGraphName,
     creds: Annotated[tuple[list[str], HTTPBasicCredentials], Depends(ui_basic_auth)],
     files: list[UploadFile] = File(...),
     overwrite: bool = False,
@@ -1121,7 +1357,7 @@ async def upload_files(
 
 @router.delete(route_prefix + "/{graphname}/uploads")
 async def clear_uploaded_files(
-    graphname: str,
+    graphname: ValidGraphName,
     creds: Annotated[tuple[list[str], HTTPBasicCredentials], Depends(ui_basic_auth)],
     filename: str | None = None,
 ):
@@ -1210,7 +1446,7 @@ async def clear_uploaded_files(
 
 @router.post(route_prefix + "/{graphname}/cloud/download")
 async def download_from_cloud(
-    graphname: str,
+    graphname: ValidGraphName,
     credentials: Annotated[HTTPBase, Depends(security)],
     request_body: dict = Body(...),
 ):
@@ -1439,7 +1675,7 @@ async def download_from_cloud(
 
 @router.get(route_prefix + "/{graphname}/cloud/list")
 async def list_cloud_downloads(
-    graphname: str,
+    graphname: ValidGraphName,
     credentials: Annotated[HTTPBase, Depends(security)],
 ):
     """
@@ -1486,7 +1722,7 @@ async def list_cloud_downloads(
 
 @router.delete(route_prefix + "/{graphname}/cloud/delete")
 async def delete_cloud_downloads(
-    graphname: str,
+    graphname: ValidGraphName,
     credentials: Annotated[HTTPBase, Depends(security)],
     filename: str = None,
 ):
@@ -1570,3 +1806,878 @@ async def delete_cloud_downloads(
         logger.debug_pii(f"Delete error trace:\n{exc}")
         raise HTTPException(status_code=500, detail=f"Error deleting files: {str(e)}")
 
+
+@router.post(f"{route_prefix}/config/llm")
+async def save_llm_config(
+    request: Request,
+    credentials: Annotated[HTTPBasicCredentials, Depends(security)],
+    llm_config_data: dict = Body(...)
+):
+    """
+    Save LLM configuration and reload services.
+    """
+    try:
+        graphname = llm_config_data.pop("graphname", None)
+        llm_access_mode = _resolve_llm_config_access(credentials, graphname)
+        graphs = auth(credentials.username, credentials.password)[0]
+        auth_header = "Basic " + base64.b64encode(
+            f"{credentials.username}:{credentials.password}".encode()
+        ).decode()
+        if _ecc_jobs_running(graphs, auth_header):
+            raise HTTPException(
+                status_code=409,
+                detail="ECC rebuild in progress. Please wait for it to complete before updating config."
+            )
+        if llm_config_lock.locked():
+            raise HTTPException(
+                status_code=409,
+                detail="LLM config update already in progress. Please try again shortly."
+            )
+        async with llm_config_lock:
+            # Save and reload in graphrag service
+            from common.config import reload_llm_config
+
+            scope = llm_config_data.pop("scope", None)
+
+            # Substitute masked sentinel values with real stored values
+            _unmask_auth(llm_config_data, llm_config)
+
+            if llm_access_mode == "chatbot_only" or (llm_access_mode == "full" and scope == "graph"):
+                # Per-graph save: write only overrides to graph config file.
+                # chatbot_only: can only set chat_service
+                # full + scope=graph: can set completion_service, chat_service, multimodal_service
+                from common.config import _config_file_lock
+
+                if not graphname:
+                    raise HTTPException(status_code=400, detail="graphname is required for per-graph config")
+
+                graph_config_dir = f"configs/graph_configs/{graphname}"
+                os.makedirs(graph_config_dir, exist_ok=True)
+                graph_config_path = os.path.join(graph_config_dir, "server_config.json")
+
+                with _config_file_lock:
+                    if os.path.exists(graph_config_path):
+                        with open(graph_config_path, "r") as f:
+                            graph_server_config = json.load(f)
+                    else:
+                        graph_server_config = {}
+
+                    graph_llm = graph_server_config.setdefault("llm_config", {})
+
+                    # Also unmask against the graph's own stored config
+                    _unmask_auth(llm_config_data, graph_llm)
+
+                    if llm_access_mode == "chatbot_only":
+                        # Graph admin: only chat_service
+                        svc_keys = ["chat_service"]
+                    else:
+                        # Superadmin per-graph: all services
+                        svc_keys = ["completion_service", "chat_service", "multimodal_service"]
+
+                    for svc_key in svc_keys:
+                        incoming = llm_config_data.get(svc_key)
+                        if incoming:
+                            graph_llm[svc_key] = incoming
+                        else:
+                            # Revert to inherit: remove override
+                            graph_llm.pop(svc_key, None)
+
+                    temp_file = f"{graph_config_path}.tmp"
+                    with open(temp_file, "w") as f:
+                        json.dump(graph_server_config, f, indent=2)
+                    os.replace(temp_file, graph_config_path)
+
+                result = {"status": "success"}
+            else:
+                # Superadmin global save
+                result = reload_llm_config(llm_config_data)
+
+            if result["status"] != "success":
+                raise HTTPException(status_code=500, detail=result["message"])
+        
+            return {
+                "status": "success",
+                "message": "Configuration saved successfully"
+            }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error saving config: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post(f"{route_prefix}/config/llm/test")
+async def test_llm_config(
+    request: Request,
+    credentials: Annotated[HTTPBasicCredentials, Depends(security)],
+    llm_test_config: dict = Body(...)
+):
+    """
+    Test LLM configuration by making actual API calls to the provider.
+    Tests completion, embedding, and multimodal services.
+    """
+    try:
+        graphname = llm_test_config.pop("graphname", None)
+        llm_access_mode = _resolve_llm_config_access(credentials, graphname)
+        # Substitute masked sentinel values with real stored values
+        _unmask_auth(llm_test_config, llm_config)
+        from common import config as cfg
+
+        test_results = {
+            "completion": {"status": "not_tested", "message": ""},
+            "chatbot": {"status": "not_tested", "message": ""},
+            "embedding": {"status": "not_tested", "message": ""},
+            "multimodal": {"status": "not_tested", "message": ""}
+        }
+
+        # Graph admins (chatbot_only) can only test chat_service
+        if llm_access_mode == "chatbot_only":
+            if "chat_service" in llm_test_config:
+                try:
+                    test_chat_config = llm_test_config["chat_service"].copy()
+                    provider = test_chat_config.get("llm_service", "openai").lower()
+                    model = test_chat_config.get("llm_model", "gpt-4o-mini")
+
+                    if "authentication_configuration" not in test_chat_config:
+                        test_chat_config["authentication_configuration"] = {}
+
+                    if hasattr(cfg, 'completion_config') and cfg.completion_config:
+                        for key in ["model_kwargs", "prompt_path", "base_url", "token_limit"]:
+                            if key not in test_chat_config and key in cfg.completion_config:
+                                test_chat_config[key] = cfg.completion_config[key]
+
+                    if "model_kwargs" not in test_chat_config:
+                        test_chat_config["model_kwargs"] = {"temperature": 0}
+                    if "prompt_path" not in test_chat_config:
+                        test_chat_config["prompt_path"] = "common/prompts/openai_gpt4/"
+
+                    llm_service = _create_llm_service(provider, test_chat_config)
+                    if llm_service:
+                        response = llm_service.llm.invoke("Say 'Connection successful' in 2 words")
+                        if not response or not str(response).strip():
+                            raise ValueError("LLM returned an empty response")
+                        test_results["chatbot"]["status"] = "success"
+                        test_results["chatbot"]["message"] = f"Chatbot LLM ({model}) connected successfully"
+                    else:
+                        test_results["chatbot"]["status"] = "error"
+                        test_results["chatbot"]["message"] = f"Provider '{provider}' not supported"
+                except Exception as e:
+                    test_results["chatbot"]["status"] = "error"
+                    test_results["chatbot"]["message"] = f"Chatbot test failed: {str(e)}"
+                    logger.error(f"Chatbot test failed for graph {graphname}: {str(e)}")
+
+            overall_status = "success" if test_results["chatbot"]["status"] == "success" else "error"
+            return {
+                "status": overall_status,
+                "message": "Connection test completed",
+                "results": {"chatbot": test_results["chatbot"]}
+            }
+
+        # Full access: test all services
+        # Test Completion Service (Default LLM Model)
+        if "completion_service" in llm_test_config or "llm_service" in llm_test_config:
+            try:
+                if "completion_service" in llm_test_config:
+                    test_completion_config = llm_test_config["completion_service"].copy()
+                    provider = test_completion_config.get("llm_service", "openai").lower()
+                    model = test_completion_config.get("llm_model", "gpt-4o-mini")
+                else:
+                    test_completion_config = {
+                        "llm_service": llm_test_config.get("llm_service", "openai"),
+                        "llm_model": llm_test_config.get("llm_model", "gpt-4o-mini"),
+                        "authentication_configuration": llm_test_config.get("authentication_configuration", {})
+                    }
+                    provider = test_completion_config["llm_service"].lower()
+                    model = test_completion_config["llm_model"]
+                
+                # Ensure authentication_configuration exists (may be at top level in single-provider mode)
+                if "authentication_configuration" not in test_completion_config:
+                    test_completion_config["authentication_configuration"] = llm_test_config.get("authentication_configuration", {})
+                
+                # Merge with existing config to get model_kwargs and prompt_path
+                if hasattr(cfg, 'completion_config') and cfg.completion_config:
+                    for key in ["model_kwargs", "prompt_path", "base_url", "token_limit"]:
+                        if key not in test_completion_config and key in cfg.completion_config:
+                            test_completion_config[key] = cfg.completion_config[key]
+                
+                # Ensure required fields exist
+                if "model_kwargs" not in test_completion_config:
+                    test_completion_config["model_kwargs"] = {"temperature": 0}
+                if "prompt_path" not in test_completion_config:
+                    test_completion_config["prompt_path"] = "common/prompts/openai_gpt4/"
+                
+                llm_service = _create_llm_service(provider, test_completion_config)
+                
+                if llm_service:
+                    response = llm_service.llm.invoke("Say 'Connection successful' in 2 words")
+                    if not response or not str(response).strip():
+                        raise ValueError("LLM returned an empty response")
+                    test_results["completion"]["status"] = "success"
+                    test_results["completion"]["message"] = f"✅ Default LLM model ({model}) connected successfully"
+                else:
+                    test_results["completion"]["status"] = "error"
+                    test_results["completion"]["message"] = f"Provider '{provider}' not supported for completion"
+                    
+            except Exception as e:
+                test_results["completion"]["status"] = "error"
+                test_results["completion"]["message"] = f"❌ Completion test failed: {str(e)}"
+                logger.error(f"Completion test failed: {str(e)}")
+        
+        # Test Chatbot Service (if different model is provided)
+        if "chatbot_service" in llm_test_config:
+            try:
+                test_chatbot_config = llm_test_config["chatbot_service"].copy()
+                provider = test_chatbot_config.get("llm_service", "openai").lower()
+                model = test_chatbot_config.get("llm_model", "gpt-4o-mini")
+                
+                # Ensure authentication_configuration exists
+                if "authentication_configuration" not in test_chatbot_config:
+                    test_chatbot_config["authentication_configuration"] = llm_test_config.get("authentication_configuration", {})
+                
+                # Merge with existing config to get model_kwargs and prompt_path
+                if hasattr(cfg, 'completion_config') and cfg.completion_config:
+                    for key in ["model_kwargs", "prompt_path", "base_url", "token_limit"]:
+                        if key not in test_chatbot_config and key in cfg.completion_config:
+                            test_chatbot_config[key] = cfg.completion_config[key]
+                
+                # Ensure required fields exist
+                if "model_kwargs" not in test_chatbot_config:
+                    test_chatbot_config["model_kwargs"] = {"temperature": 0}
+                if "prompt_path" not in test_chatbot_config:
+                    test_chatbot_config["prompt_path"] = "common/prompts/openai_gpt4/"
+                
+                llm_service = _create_llm_service(provider, test_chatbot_config)
+                
+                if llm_service:
+                    response = llm_service.llm.invoke("Say 'Connection successful' in 2 words")
+                    if not response or not str(response).strip():
+                        raise ValueError("LLM returned an empty response")
+                    test_results["chatbot"]["status"] = "success"
+                    test_results["chatbot"]["message"] = f"✅ Chatbot LLM model ({model}) connected successfully"
+                else:
+                    test_results["chatbot"]["status"] = "error"
+                    test_results["chatbot"]["message"] = f"Provider '{provider}' not supported for chatbot"
+                    
+            except Exception as e:
+                test_results["chatbot"]["status"] = "error"
+                test_results["chatbot"]["message"] = f"❌ Chatbot test failed: {str(e)}"
+                logger.error(f"Chatbot test failed: {str(e)}")
+        
+        # Test Embedding Service
+        if "embedding_service" in llm_test_config:
+            try:
+                test_embedding_config = llm_test_config["embedding_service"].copy()
+                provider = test_embedding_config.get("embedding_model_service", "openai").lower()
+                model = test_embedding_config.get("model_name", "text-embedding-3-small")
+                
+                # Ensure authentication_configuration exists
+                if "authentication_configuration" not in test_embedding_config:
+                    test_embedding_config["authentication_configuration"] = llm_test_config.get("authentication_configuration", {})
+                
+                # Merge with existing config
+                if hasattr(cfg, 'embedding_config') and cfg.embedding_config:
+                    for key in ["dimensions", "token_limit"]:
+                        if key not in test_embedding_config and key in cfg.embedding_config:
+                            test_embedding_config[key] = cfg.embedding_config[key]
+                
+                embedding_service_test = _create_embedding_service(provider, test_embedding_config)
+                
+                if embedding_service_test:
+                    # Test with a simple text
+                    embeddings = embedding_service_test.embed_query("test connection")
+                    if embeddings and len(embeddings) > 0:
+                        test_results["embedding"]["status"] = "success"
+                        test_results["embedding"]["message"] = f"✅ Embedding model ({model}) connected successfully"
+                    else:
+                        test_results["embedding"]["status"] = "error"
+                        test_results["embedding"]["message"] = "❌ Embedding returned empty result"
+                else:
+                    test_results["embedding"]["status"] = "error"
+                    test_results["embedding"]["message"] = f"Provider '{provider}' not supported for embeddings"
+                    
+            except Exception as e:
+                test_results["embedding"]["status"] = "error"
+                test_results["embedding"]["message"] = f"❌ Embedding test failed: {str(e)}"
+                logger.error(f"Embedding test failed: {str(e)}")
+        
+        # Test Multimodal Service
+        if "multimodal_service" in llm_test_config:
+            try:
+                test_multimodal_config = llm_test_config["multimodal_service"].copy()
+                provider = test_multimodal_config.get("llm_service", "openai").lower()
+                model = test_multimodal_config.get("llm_model", "gpt-4o")
+                
+                # Ensure authentication_configuration exists
+                if "authentication_configuration" not in test_multimodal_config:
+                    test_multimodal_config["authentication_configuration"] = llm_test_config.get("authentication_configuration", {})
+                
+                # Merge with existing config to get model_kwargs and prompt_path
+                if hasattr(cfg, 'multimodal_config') and cfg.multimodal_config:
+                    for key in ["model_kwargs", "prompt_path", "base_url", "token_limit"]:
+                        if key not in test_multimodal_config and key in cfg.multimodal_config:
+                            test_multimodal_config[key] = cfg.multimodal_config[key]
+                elif hasattr(cfg, 'completion_config') and cfg.completion_config:
+                    # Fallback to completion config
+                    for key in ["model_kwargs", "prompt_path", "base_url", "token_limit"]:
+                        if key not in test_multimodal_config and key in cfg.completion_config:
+                            test_multimodal_config[key] = cfg.completion_config[key]
+                
+                # Ensure required fields exist
+                if "model_kwargs" not in test_multimodal_config:
+                    test_multimodal_config["model_kwargs"] = {"temperature": 0}
+                if "prompt_path" not in test_multimodal_config:
+                    test_multimodal_config["prompt_path"] = "common/prompts/openai_gpt4/"
+                
+                multimodal_service = _create_llm_service(provider, test_multimodal_config)
+                
+                if multimodal_service:
+                    response = multimodal_service.llm.invoke("Say 'Connection successful' in 2 words")
+                    if not response or not str(response).strip():
+                        raise ValueError("Multimodal LLM returned an empty response")
+                    test_results["multimodal"]["status"] = "success"
+                    test_results["multimodal"]["message"] = f"✅ Multimodal model ({model}) connected successfully"
+                else:
+                    test_results["multimodal"]["status"] = "error"
+                    test_results["multimodal"]["message"] = f"Provider '{provider}' not supported for multimodal"
+                    
+            except Exception as e:
+                test_results["multimodal"]["status"] = "error"
+                test_results["multimodal"]["message"] = f"❌ Multimodal test failed: {str(e)}"
+                logger.error(f"Multimodal test failed: {str(e)}")
+        
+        # Determine overall status
+        all_success = all(result["status"] == "success" for result in test_results.values() if result["status"] != "not_tested")
+        any_error = any(result["status"] == "error" for result in test_results.values())
+        
+        overall_status = "success" if all_success and not any_error else "error" if any_error else "partial"
+        
+        return {
+            "status": overall_status,
+            "message": "Connection test completed",
+            "results": test_results
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"LLM connection test failed: {str(e)}")
+        return {
+            "status": "error",
+            "message": f"Test failed: {str(e)}",
+            "results": test_results
+        }
+
+
+MASKED_SECRET = "********"
+
+
+def _mask_secret_values(auth_config: dict) -> dict:
+    """Replace all values in an authentication_configuration dict with the masked sentinel."""
+    return {k: MASKED_SECRET for k in auth_config}
+
+
+def _unmask_auth(incoming: dict, stored_config: dict):
+    """
+    In-place: replace MASKED_SECRET values in incoming authentication_configuration
+    with the real values from stored_config.
+
+    Works on both top-level and per-service authentication_configuration.
+    """
+    def _unmask_dict(incoming_auth, stored_auth):
+        if not isinstance(incoming_auth, dict) or not isinstance(stored_auth, dict):
+            return
+        for k, v in incoming_auth.items():
+            if v == MASKED_SECRET:
+                incoming_auth[k] = stored_auth.get(k, "")
+
+    # Top-level authentication_configuration
+    if "authentication_configuration" in incoming:
+        stored_top = stored_config.get("authentication_configuration", {})
+        _unmask_dict(incoming["authentication_configuration"], stored_top)
+
+    # Per-service authentication_configuration
+    for svc_key in ["completion_service", "embedding_service", "multimodal_service", "chat_service"]:
+        svc = incoming.get(svc_key)
+        if svc and "authentication_configuration" in svc:
+            stored_svc = stored_config.get(svc_key, {})
+            stored_svc_auth = stored_svc.get("authentication_configuration", {})
+            _unmask_dict(svc["authentication_configuration"], stored_svc_auth)
+
+
+def _strip_auth(config: dict) -> dict:
+    """Deep copy a config dict and mask all secret values in authentication_configuration sections."""
+    result = copy.deepcopy(config)
+    if "authentication_configuration" in result and isinstance(result["authentication_configuration"], dict):
+        result["authentication_configuration"] = _mask_secret_values(result["authentication_configuration"])
+    for service_key in ["completion_service", "embedding_service", "multimodal_service", "chat_service"]:
+        svc = result.get(service_key)
+        if svc and "authentication_configuration" in svc and isinstance(svc["authentication_configuration"], dict):
+            svc["authentication_configuration"] = _mask_secret_values(svc["authentication_configuration"])
+    return result
+
+
+@router.get(f"{route_prefix}/config")
+async def get_config(
+    credentials: Annotated[HTTPBasicCredentials, Depends(security)],
+    graphname: str | None = None,
+    scope: str | None = None,
+):
+    """
+    Get current server configuration to display in UI.
+    Returns config WITHOUT any API keys or secrets.
+
+    Query params:
+        scope: "graph" to get per-graph overrides (superadmin only).
+               Default (None or "global") returns global config.
+    """
+    try:
+        llm_access_mode = _resolve_llm_config_access(credentials, graphname)
+        safe_llm_config = _strip_auth(llm_config)
+
+        if llm_access_mode == "chatbot_only":
+            # Load graph-specific chat_service if it exists
+            graph_chat_service = None
+            if graphname:
+                from common.config import _load_graph_llm_config
+                graph_llm = _load_graph_llm_config(graphname)
+                graph_chat_service = graph_llm.get("chat_service")
+                if graph_chat_service:
+                    graph_chat_service = copy.deepcopy(graph_chat_service)
+                    if "authentication_configuration" in graph_chat_service and isinstance(graph_chat_service["authentication_configuration"], dict):
+                        graph_chat_service["authentication_configuration"] = _mask_secret_values(graph_chat_service["authentication_configuration"])
+
+            # Global chat info for "Inherited from" display
+            global_chat = llm_config.get("chat_service", llm_config.get("completion_service", {}))
+            global_chat_info = {
+                "llm_service": global_chat.get("llm_service", ""),
+                "llm_model": global_chat.get("llm_model", ""),
+            }
+
+            return {
+                "llm_config": safe_llm_config,
+                "llm_config_access": "chatbot_only",
+                "chatbot_config": graph_chat_service,
+                "global_chat_info": global_chat_info,
+            }
+
+        # Full access (superadmin/globaldesigner)
+        if scope == "graph" and graphname:
+            # Return per-graph overrides + global config for reference
+            from common.config import _load_graph_config
+            graph_cfg = _load_graph_config(graphname)
+            graph_llm = graph_cfg.get("llm_config", {})
+            # Mask auth in graph overrides
+            safe_graph_overrides = {}
+            for svc_key in ["completion_service", "chat_service", "embedding_service", "multimodal_service"]:
+                svc_override = graph_llm.get(svc_key)
+                if svc_override:
+                    svc_copy = copy.deepcopy(svc_override)
+                    if "authentication_configuration" in svc_copy and isinstance(svc_copy["authentication_configuration"], dict):
+                        svc_copy["authentication_configuration"] = _mask_secret_values(svc_copy["authentication_configuration"])
+                    safe_graph_overrides[svc_key] = svc_copy
+
+            return {
+                "llm_config": safe_llm_config,
+                "graph_overrides": safe_graph_overrides,
+                "graphrag_config": graphrag_config,
+                "graphrag_overrides": graph_cfg.get("graphrag_config", {}),
+                "llm_config_access": "full",
+                "scope": "graph",
+            }
+
+        safe_db_config = copy.deepcopy(db_config)
+        if safe_db_config.get("password"):
+            safe_db_config["password"] = MASKED_SECRET
+        if safe_db_config.get("apiToken"):
+            safe_db_config["apiToken"] = MASKED_SECRET
+
+        return {
+            "llm_config": safe_llm_config,
+            "db_config": safe_db_config,
+            "graphrag_config": graphrag_config,
+            "llm_config_access": "full",
+            "scope": "global",
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error returning config: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Failed to return config: {str(e)}")
+
+
+@router.post(f"{route_prefix}/config/db/test")
+async def test_db_connection(
+    request: Request,
+    credentials: Annotated[HTTPBasicCredentials, Depends(security)],
+    db_test_config: dict = Body(...)
+):
+    """
+    Test database connection with provided credentials from UI.
+    """
+    try:
+        _require_roles(credentials, {"superuser"})
+        # Substitute masked sentinel with stored values
+        if db_test_config.get("password") == MASKED_SECRET:
+            db_test_config["password"] = db_config.get("password", "")
+        if db_test_config.get("apiToken") == MASKED_SECRET:
+            db_test_config["apiToken"] = db_config.get("apiToken", "")
+        test_conn = TigerGraphConnection(
+            host=db_test_config["hostname"],
+            username=db_test_config["username"],
+            password=db_test_config["password"],
+            gsPort=db_test_config["gsPort"],
+            restppPort=db_test_config["restppPort"],
+            graphname="",
+        )
+        
+        # Test connection by listing users
+        if db_test_config.get("getToken", False):
+            test_conn.getToken()
+        
+        test_conn.gsql("LS USER")
+        
+        return {
+            "status": "success",
+            "message": "Connection successful"
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"DB connection test failed: {str(e)}")
+        return {
+            "status": "error",
+            "message": f"Connection failed: {str(e)}"
+        }
+
+
+@router.post(f"{route_prefix}/config/db")
+async def save_db_config(
+    request: Request,
+    credentials: Annotated[HTTPBasicCredentials, Depends(security)],
+    db_config_data: dict = Body(...)
+):
+    """
+    Save GraphDB configuration to server_config.json.
+    """
+    try:
+        _require_roles(credentials, {"superuser"})
+        graphs = auth(credentials.username, credentials.password)[0]
+        auth_header = "Basic " + base64.b64encode(
+            f"{credentials.username}:{credentials.password}".encode()
+        ).decode()
+        if _ecc_jobs_running(graphs, auth_header):
+            raise HTTPException(
+                status_code=409,
+                detail="ECC rebuild in progress. Please wait for it to complete before updating config."
+            )
+        from common.config import reload_db_config
+        # Substitute masked sentinel with stored values
+        if db_config_data.get("password") == MASKED_SECRET:
+            db_config_data["password"] = db_config.get("password", "")
+        if db_config_data.get("apiToken") == MASKED_SECRET:
+            db_config_data["apiToken"] = db_config.get("apiToken", "")
+
+        result = reload_db_config(db_config_data)
+        if result["status"] != "success":
+            raise HTTPException(status_code=500, detail=result["message"])
+        
+        logger.info("GraphDB configuration saved successfully")
+        
+        return {
+            "status": "success",
+            "message": "GraphDB configuration saved successfully"
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error saving GraphDB config: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Failed to save GraphDB config: {str(e)}")
+
+
+@router.post(f"{route_prefix}/config/graphrag")
+async def save_graphrag_config(
+    request: Request,
+    credentials: Annotated[HTTPBasicCredentials, Depends(security)],
+    graphrag_config_data: dict = Body(...)
+):
+    """
+    Save GraphRAG configuration.
+    scope=graph saves per-graph overrides; default saves to global config.
+    """
+    try:
+        _require_roles(credentials, {"superuser", "globaldesigner"})
+        graphs = auth(credentials.username, credentials.password)[0]
+        auth_header = "Basic " + base64.b64encode(
+            f"{credentials.username}:{credentials.password}".encode()
+        ).decode()
+        if _ecc_jobs_running(graphs, auth_header):
+            raise HTTPException(
+                status_code=409,
+                detail="ECC rebuild in progress. Please wait for it to complete before updating config."
+            )
+        from common.config import SERVER_CONFIG, reload_graphrag_config, _config_file_lock
+
+        scope = graphrag_config_data.pop("scope", None)
+        graphname = graphrag_config_data.pop("graphname", None)
+
+        if scope == "graph":
+            if not graphname:
+                raise HTTPException(status_code=400, detail="graphname is required for per-graph config")
+
+            graph_config_dir = f"configs/graph_configs/{graphname}"
+            os.makedirs(graph_config_dir, exist_ok=True)
+            graph_config_path = os.path.join(graph_config_dir, "server_config.json")
+
+            with _config_file_lock:
+                if os.path.exists(graph_config_path):
+                    with open(graph_config_path, "r") as f:
+                        graph_server_config = json.load(f)
+                else:
+                    graph_server_config = {}
+
+                if graphrag_config_data:
+                    graph_server_config["graphrag_config"] = graphrag_config_data
+                else:
+                    # Revert to inherit: remove overrides
+                    graph_server_config.pop("graphrag_config", None)
+
+                temp_file = f"{graph_config_path}.tmp"
+                with open(temp_file, "w") as f:
+                    json.dump(graph_server_config, f, indent=2)
+                os.replace(temp_file, graph_config_path)
+
+            return {
+                "status": "success",
+                "message": f"GraphRAG configuration saved for graph {graphname}"
+            }
+        else:
+            # Global save
+            with _config_file_lock:
+                with open(SERVER_CONFIG, "r") as f:
+                    server_config = json.load(f)
+
+                server_config["graphrag_config"] = graphrag_config_data
+
+                temp_file = f"{SERVER_CONFIG}.tmp"
+                with open(temp_file, "w") as f:
+                    json.dump(server_config, f, indent=2)
+                os.replace(temp_file, SERVER_CONFIG)
+
+            # Reload from file (applies defaults for missing keys like chunker/extractor)
+            result = reload_graphrag_config()
+            if result["status"] != "success":
+                raise HTTPException(status_code=500, detail=result["message"])
+
+            return {
+                "status": "success",
+                "message": "GraphRAG configuration saved successfully"
+            }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error saving GraphRAG config: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Failed to save GraphRAG config: {str(e)}")
+
+
+def split_prompt_template(prompt_content: str, prompt_type: str) -> dict:
+    """
+    Split prompt into editable content and template variables that users should not modify.
+    Returns: {"editable_content": str, "template_variables": str}
+    """
+    if prompt_type == "chatbot_response":
+        pattern = r'(Question: \{question\}.*?)$'
+        match = re.search(pattern, prompt_content, re.DOTALL)
+        if match:
+            template_vars = match.group(1).strip()
+            editable = prompt_content[:match.start()].strip()
+            return {"editable_content": editable, "template_variables": template_vars}
+
+    elif prompt_type == "query_generation":
+        pattern = r'(\{format_instructions\}.*?)$'
+        match = re.search(pattern, prompt_content, re.DOTALL)
+        if match:
+            template_vars = match.group(1).strip()
+            editable = prompt_content[:match.start()].strip()
+            return {"editable_content": editable, "template_variables": template_vars}
+
+    elif prompt_type == "community_summarization":
+        pattern = r'(#######\s*-Data-.*?)$'
+        match = re.search(pattern, prompt_content, re.DOTALL)
+        if match:
+            template_vars = match.group(1).strip()
+            editable = prompt_content[:match.start()].strip()
+            return {"editable_content": editable, "template_variables": template_vars}
+
+    return {"editable_content": prompt_content, "template_variables": ""}
+
+
+@router.get(f"{route_prefix}/prompts")
+async def get_prompts(
+    credentials: Annotated[HTTPBasicCredentials, Depends(security)],
+    graphname: str | None = None,
+):
+    """
+    Get all customizable prompts.
+    Returns chatbot_response, entity_relationship, community_summarization, and query_generation prompts.
+    """
+    try:
+        access_level = _require_prompt_access(credentials, graphname)
+        active_config = get_chat_config(graphname)
+        default_prompt_path = active_config.get("prompt_path", "./common/prompts/openai_gpt4/")
+        if default_prompt_path.startswith("./"):
+            default_prompt_path = default_prompt_path[2:]
+        default_prompt_path = default_prompt_path.rstrip("/")
+
+        # Per-graph prompt overrides directory (only contains customized files)
+        graph_prompt_dir = f"configs/graph_configs/{graphname}/prompts" if graphname else None
+
+        def _resolve_prompt_file(filename: str) -> str | None:
+            """Find prompt file: graph override first, then default."""
+            if graph_prompt_dir:
+                graph_file = os.path.join(graph_prompt_dir, filename)
+                if os.path.exists(graph_file):
+                    return graph_file
+            default_file = os.path.join(default_prompt_path, filename)
+            if os.path.exists(default_file):
+                return default_file
+            return None
+
+        def _read_prompt(filename: str, prompt_type: str) -> dict:
+            filepath = _resolve_prompt_file(filename)
+            if filepath:
+                with open(filepath, "r", encoding="utf-8") as f:
+                    return split_prompt_template(f.read(), prompt_type)
+            return {"editable_content": "", "template_variables": ""}
+
+        prompts = {}
+        prompts["chatbot_response"] = _read_prompt("chatbot_response.txt", "chatbot_response")
+        prompts["entity_relationship"] = _read_prompt("entity_relationship_extraction.txt", "entity_relationship")
+        prompts["community_summarization"] = _read_prompt("community_summarization.txt", "community_summarization")
+
+        query_gen = _read_prompt("map_question_to_schema.txt", "query_generation")
+        if not query_gen["editable_content"]:
+            query_gen = _read_prompt("query_generation.txt", "query_generation")
+        prompts["query_generation"] = query_gen
+
+        # Graph-admin (chatbot_only) only sees chatbot_response
+        if access_level == "chatbot_only":
+            prompts = {"chatbot_response": prompts.get("chatbot_response", {"editable_content": "", "template_variables": ""})}
+
+        return {
+            "prompts": prompts,
+            "prompt_path": default_prompt_path,
+            "configured_provider": active_config.get("llm_service", "openai")
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error fetching prompts: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Failed to fetch prompts: {str(e)}")
+
+
+@router.post(f"{route_prefix}/prompts")
+async def save_prompts(
+    credentials: Annotated[HTTPBasicCredentials, Depends(security)],
+    prompt_data: dict = Body(...)
+):
+    """
+    Save customized prompts.
+    Expects: {
+        "prompt_type": "chatbot_response|entity_relationship|community_summarization|query_generation",
+        "editable_content": "...",
+        "template_variables": "...",
+        "graphname": "..."  (optional - graph-admin users must supply this)
+    }
+    """
+    try:
+        graphname = prompt_data.get("graphname")
+        access_level = _require_prompt_access(credentials, graphname)
+        prompt_type = prompt_data.get("prompt_type")
+
+        # Graph-admin (chatbot_only) can only edit chatbot_response prompt
+        if access_level == "chatbot_only" and prompt_type != "chatbot_response":
+            raise HTTPException(status_code=403, detail="Graph admins can only edit the chatbot response prompt.")
+        editable_content = prompt_data.get("editable_content")
+        template_variables = prompt_data.get("template_variables", "")
+
+        if not editable_content:
+            editable_content = prompt_data.get("content")
+
+        if not prompt_type or not editable_content:
+            raise HTTPException(status_code=400, detail="prompt_type and editable_content are required")
+
+        if template_variables:
+            content = editable_content + "\n\n" + template_variables
+        else:
+            content = editable_content
+
+        if graphname:
+            # Per-graph: only write the single customized prompt file to the override dir.
+            # Non-customized prompts fall back to the global prompt_path at runtime.
+            graph_prompt_dir = f"configs/graph_configs/{graphname}/prompts"
+            os.makedirs(graph_prompt_dir, exist_ok=True)
+            prompt_path = graph_prompt_dir
+        else:
+            # Global: seed persistent dir from defaults if needed
+            default_prompt_path = get_chat_config().get("prompt_path", "./common/prompts/openai_gpt4/")
+            if default_prompt_path.startswith("./"):
+                default_prompt_path = default_prompt_path[2:]
+            default_prompt_path = default_prompt_path.rstrip("/")
+
+            persistent_prompt_dir = "configs/prompts"
+            if not default_prompt_path.startswith("configs/"):
+                os.makedirs(persistent_prompt_dir, exist_ok=True)
+                if os.path.exists(default_prompt_path):
+                    for fname in os.listdir(default_prompt_path):
+                        src = os.path.join(default_prompt_path, fname)
+                        dst = os.path.join(persistent_prompt_dir, fname)
+                        if os.path.isfile(src) and not os.path.exists(dst):
+                            shutil.copy2(src, dst)
+                from common.config import reload_llm_config, _config_file_lock
+                with _config_file_lock:
+                    with open(SERVER_CONFIG, "r") as f:
+                        server_cfg = json.load(f)
+                    server_cfg["llm_config"]["completion_service"]["prompt_path"] = f"./{persistent_prompt_dir}/"
+                    temp_file = f"{SERVER_CONFIG}.tmp"
+                    with open(temp_file, "w") as f:
+                        json.dump(server_cfg, f, indent=2)
+                    os.replace(temp_file, SERVER_CONFIG)
+                reload_llm_config()
+                prompt_path = persistent_prompt_dir
+            else:
+                prompt_path = default_prompt_path
+
+        prompt_type_to_file = {
+            "chatbot_response": "chatbot_response.txt",
+            "entity_relationship": "entity_relationship_extraction.txt",
+            "community_summarization": "community_summarization.txt",
+            "query_generation": "map_question_to_schema.txt",
+        }
+
+        if prompt_type not in prompt_type_to_file:
+            raise HTTPException(status_code=400, detail=f"Invalid prompt_type: {prompt_type}")
+
+        file_path = os.path.join(prompt_path, prompt_type_to_file[prompt_type])
+        temp_file = f"{file_path}.tmp"
+        with open(temp_file, "w", encoding="utf-8") as f:
+            f.write(content)
+        os.replace(temp_file, file_path)
+
+        messages = {
+            "chatbot_response": "Chatbot response prompt saved successfully",
+            "entity_relationship": "Entity relationship prompt saved successfully",
+            "community_summarization": "Community summarization prompt saved successfully",
+            "query_generation": "Schema instructions prompt saved successfully",
+        }
+        return {"status": "success", "message": messages[prompt_type]}
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error saving prompt: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Failed to save prompt: {str(e)}")
\ No newline at end of file
diff --git a/graphrag/app/supportai/retrievers/BaseRetriever.py b/graphrag/app/supportai/retrievers/BaseRetriever.py
index 3e1e556..271e34c 100644
--- a/graphrag/app/supportai/retrievers/BaseRetriever.py
+++ b/graphrag/app/supportai/retrievers/BaseRetriever.py
@@ -2,18 +2,16 @@
 from common.embeddings.base_embedding_store import EmbeddingStore
 from common.metrics.tg_proxy import TigerGraphConnectionProxy
 from common.llm_services.base_llm import LLM_Model
-from common.py_schemas import CandidateScore, CandidateGenerator, GraphRAGAnswerOutput
+from common.py_schemas import CandidateScore, CandidateGenerator, GraphRAGAnswerOutput, CommunityAnswer
 from common.utils.token_calculator import get_token_calculator
-from common.config import completion_config
+from common.config import get_chat_config, get_graphrag_config
 
 from langchain_core.output_parsers import StrOutputParser, PydanticOutputParser
 from langchain_core.prompts import ChatPromptTemplate, PromptTemplate
-from langchain.output_parsers import OutputFixingParser
-from langchain_community.callbacks.manager import get_openai_callback
-
 
 import re
 import logging
+from concurrent.futures import ThreadPoolExecutor
 
 class BaseRetriever:
     def __init__(
@@ -29,7 +27,10 @@ def __init__(
         self.embedding_store = embedding_store
         self.embedding_store.set_graphname(connection.graphname)
         self.logger = logging.getLogger(__name__)
-        self.token_calculator = get_token_calculator(token_limit=completion_config.get("token_limit"), model_name=completion_config.get("llm_model"))
+        # Use llm_service's own config when available (chatbot path);
+        # fall back to get_chat_config() (direct supportai API path).
+        llm_cfg = getattr(llm_service, "config", None) or get_chat_config()
+        self.token_calculator = get_token_calculator(token_limit=llm_cfg.get("token_limit"), model_name=llm_cfg.get("llm_model"))
 
     def _install_query(self, query_name):
         self.logger.info(f"Installing query {query_name}")
@@ -58,9 +59,8 @@ def _check_query_install(self, query_name):
 
     def _question_to_keywords(self, question, top_k, verbose):
         keyword_parser = PydanticOutputParser(pydantic_object=CandidateGenerator)
-
         keyword_prompt = PromptTemplate(
-            template = self.llm_service.keyword_extraction_prompt,
+            template=self.llm_service.keyword_extraction_prompt,
             input_variables=["question"],
             partial_variables={"format_instructions": keyword_parser.get_format_instructions()}
         )
@@ -68,65 +68,74 @@ def _question_to_keywords(self, question, top_k, verbose):
         if verbose:
             self.logger.info("Prompt to LLM:\n" + keyword_prompt.invoke({"question": question}).to_string())
 
-        model = self.llm_service.model
-
-        chain = keyword_prompt | model | keyword_parser
-
-        usage_data = {}
-        with get_openai_callback() as cb:
-            answer = chain.invoke({"question": question})
-
-            usage_data["input_tokens"] = cb.prompt_tokens
-            usage_data["output_tokens"] = cb.completion_tokens
-            usage_data["total_tokens"] = cb.total_tokens
-            usage_data["cost"] = cb.total_cost
-            self.logger.info(f"question_to_keywords usage: {usage_data}")
+        answer = self.llm_service.invoke_with_parser(
+            keyword_prompt, keyword_parser,
+            {"question": question}, caller_name="question_to_keywords",
+        )
 
         if verbose:
             self.logger.info(f"Extracted keywords \"{answer}\" from question \"{question}\" by LLM")
 
-        # sort list by quality score
         res = answer.candidates
         res.sort(key=lambda x: x.quality_score, reverse=True)
-
-        keywords = [x.candidate for x in res[:top_k]]
-
-        return keywords
+        return [x.candidate for x in res[:top_k]]
 
     def _expand_question(self, question, top_k, verbose):
-        question_parser = PydanticOutputParser(pydantic_object=CandidateGenerator)
-
-        QUESTION_PROMPT = PromptTemplate(
-            template = self.llm_service.question_expansion_prompt,
+        expansion_parser = PydanticOutputParser(pydantic_object=CandidateGenerator)
+        prompt = PromptTemplate(
+            template=self.llm_service.question_expansion_prompt,
             input_variables=["question"],
-            partial_variables={"format_instructions": question_parser.get_format_instructions()}
+            partial_variables={"format_instructions": expansion_parser.get_format_instructions()}
         )
 
-        model = self.llm_service.model
-
-        chain = QUESTION_PROMPT | model | question_parser
-        #chain = QUESTION_PROMPT | model
-
-        usage_data = {}
-        with get_openai_callback() as cb:
-            answer = chain.invoke({"question": question})
-
-            usage_data["input_tokens"] = cb.prompt_tokens
-            usage_data["output_tokens"] = cb.completion_tokens
-            usage_data["total_tokens"] = cb.total_tokens
-            usage_data["cost"] = cb.total_cost
-            self.logger.info(f"expand_question usage: {usage_data}")
+        answer = self.llm_service.invoke_with_parser(
+            prompt, expansion_parser,
+            {"question": question}, caller_name="expand_question",
+        )
 
         if verbose:
             self.logger.info(f"Expanded question \"{question}\" from LLM: {answer}")
 
-        # sort list by quality score
         res = answer.candidates
         res.sort(key=lambda x: x.quality_score, reverse=True)
+        return [x.candidate for x in res[:top_k]]
+
+    def _score_candidate(self, question, context):
+        """Score a single context chunk against the question using the LLM."""
+        scoring_parser = PydanticOutputParser(pydantic_object=CommunityAnswer)
+        prompt = PromptTemplate(
+            template=self.llm_service.graphrag_scoring_prompt,
+            input_variables=["question", "context"],
+            partial_variables={"format_instructions": scoring_parser.get_format_instructions()}
+        )
+
+        try:
+            return self.llm_service.invoke_with_parser(
+                prompt, scoring_parser,
+                {"question": question, "context": context},
+                caller_name="score_candidate",
+            )
+        except Exception:
+            self.logger.warning("score_candidate: all parsing failed, returning score 0")
+            return CommunityAnswer(answer=str(context).strip(), quality_score=0)
+
+    def _score_candidates(self, question, contexts, top_k=None):
+        """Score multiple context chunks in parallel and return top-k ranked candidates."""
+        if not contexts:
+            return []
 
-        questions = [x.candidate for x in res[:top_k]]
+        graphrag_cfg = get_graphrag_config(self.conn.graphname if self.conn else None)
+        max_workers = graphrag_cfg.get("default_concurrency", 10)
 
-        return questions
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            futures = [executor.submit(self._score_candidate, question, c) for c in contexts]
+            results = [f.result() for f in futures]
+
+        results.sort(key=lambda x: x.quality_score, reverse=True)
+        if top_k is not None:
+            results = results[:top_k]
+
+        return [{"candidate_answer": x.answer, "score": x.quality_score} for x in results]
 
     def _generate_response(self, question, retrieved, query = "", verbose = False):
         # Truncate retrieved sources to fit within token limit
@@ -140,24 +149,20 @@ def _generate_response(self, question, retrieved, query = "", verbose = False):
                     retrieved = self.token_calculator.truncate_to_token_limit(retrieved, max_context_tokens)
                     self.logger.info(f"Truncated retrieved text from {retrieved_tokens} to {max_context_tokens} tokens")
 
-        model = self.llm_service.llm
+        response_parser = PydanticOutputParser(pydantic_object=GraphRAGAnswerOutput)
         prompt = ChatPromptTemplate.from_template(self.llm_service.chatbot_response_prompt)
-        output_parser = PydanticOutputParser(pydantic_object=GraphRAGAnswerOutput)
+        input_vars = {
+            "question": question, "context": retrieved, "query": query,
+            "format_instructions": response_parser.get_format_instructions(),
+        }
 
         if verbose:
-            self.logger.info("Prompt to LLM:\n" + prompt.invoke({"question": question, "context": retrieved, "query": query, "format_instructions": output_parser.get_format_instructions()}).to_string())
-
-        chain = prompt | model | output_parser
+            self.logger.info("Prompt to LLM:\n" + prompt.invoke(input_vars).to_string())
 
-        usage_data = {}
-        with get_openai_callback() as cb:
-            generated = chain.invoke({"question": question, "context": retrieved, "query": query, "format_instructions": output_parser.get_format_instructions()})
-
-            usage_data["input_tokens"] = cb.prompt_tokens
-            usage_data["output_tokens"] = cb.completion_tokens
-            usage_data["total_tokens"] = cb.total_tokens
-            usage_data["cost"] = cb.total_cost
-            self.logger.info(f"generate_response usage: {usage_data}")
+        generated = self.llm_service.invoke_with_parser(
+            prompt, response_parser,
+            input_vars, caller_name="generate_response",
+        )
 
         return {"response": generated.generated_answer, "retrieved": retrieved}
 
@@ -174,23 +179,12 @@ def _generate_embedding(self, text, str_mode: bool = False) -> str:
             return embedding
 
     def _hyde_embedding(self, text, str_mode: bool = False) -> str:
-        model = self.llm_service.llm
-        prompt = self.llm_service.hyde_prompt
-
-        prompt = ChatPromptTemplate.from_template(prompt)
-        output_parser = StrOutputParser()
+        prompt = ChatPromptTemplate.from_template(self.llm_service.hyde_prompt)
 
-        chain = prompt | model | output_parser
-
-        usage_data = {}
-        with get_openai_callback() as cb:
-            generated = chain.invoke({"question": text})
-
-            usage_data["input_tokens"] = cb.prompt_tokens
-            usage_data["output_tokens"] = cb.completion_tokens
-            usage_data["total_tokens"] = cb.total_tokens
-            usage_data["cost"] = cb.total_cost
-            self.logger.info(f"hyde_embedding usage: {usage_data}")
+        generated = self.llm_service.invoke_with_parser(
+            prompt, StrOutputParser(),
+            {"question": text}, caller_name="hyde_embedding",
+        )
 
         return self._generate_embedding(generated, str_mode)
 
diff --git a/graphrag/app/supportai/retrievers/CommunityRetriever.py b/graphrag/app/supportai/retrievers/CommunityRetriever.py
index b86e101..466cf4d 100644
--- a/graphrag/app/supportai/retrievers/CommunityRetriever.py
+++ b/graphrag/app/supportai/retrievers/CommunityRetriever.py
@@ -1,31 +1,8 @@
 import json
-import asyncio
-from concurrent.futures import ThreadPoolExecutor
-
-from langchain_core.output_parsers import PydanticOutputParser
-from langchain_core.prompts import PromptTemplate
-from langchain_community.callbacks.manager import get_openai_callback
-
 
 from supportai.retrievers import BaseRetriever
 from common.metrics.tg_proxy import TigerGraphConnectionProxy
 from common.llm_services import LLM_Model
-from common.py_schemas import CommunityAnswer
-
-answer_parser = PydanticOutputParser(pydantic_object=CommunityAnswer)
-
-ANSWER_PROMPT = PromptTemplate(template = """
-You are a helpful assistant responsible for generating an answer to the question below using the data provided.
-Include a quality score for the answer, based on how well it answers the question. The quality score should be between 0 (poor) and 100 (excellent).
-                                                
-Question: {question}
-Context: {context}
-
-{format_instructions}
-""",
-input_variables=["question", "context"],
-partial_variables={"format_instructions": answer_parser.get_format_instructions()}
-)
 
 
 class CommunityRetriever(BaseRetriever):
@@ -103,43 +80,6 @@ def search(self, question, community_level: int, top_k: int = 5, similarity_thre
                 res[1]["verbose"]["expanded_questions"] = questions
         return res
     
-    async def _generate_candidate(self, question, context):
-        answer_parser = PydanticOutputParser(pydantic_object=CommunityAnswer)
-
-        ANSWER_PROMPT = PromptTemplate(
-            template = self.llm_service.graphrag_scoring_prompt,
-            input_variables=["question", "context"],
-            partial_variables={"format_instructions": answer_parser.get_format_instructions()}
-        )
-
-        model = self.llm_service.model
-
-        chain = ANSWER_PROMPT | model | answer_parser
-
-        usage_data = {}
-        with get_openai_callback() as cb:
-            answer = await chain.ainvoke(
-                {
-                    "question": question,
-                    "context": context,
-                }
-            )
-            usage_data["input_tokens"] = cb.prompt_tokens
-            usage_data["output_tokens"] = cb.completion_tokens
-            usage_data["total_tokens"] = cb.total_tokens
-            usage_data["cost"] = cb.total_cost
-            self.logger.info(f"generate_candidate usage: {usage_data}")
-
-        return answer
-    
-    def gather_candidates(self, question, context):
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-        tasks = [self._generate_candidate(question, c) for c in context]
-        res = loop.run_until_complete(asyncio.gather(*tasks))
-        loop.close()
-        return res
-    
     def retrieve_answer(self,
                         question: str,
                         community_level: int,
@@ -151,25 +91,17 @@ def retrieve_answer(self,
                         combine: bool = False,
                         verbose: bool = False):
         retrieved = self.search(question, community_level, top_k, similarity_threshold, expand, with_chunk, with_doc, verbose)
-        
-        context = []
+
         if combine:
+            context = []
             for x in retrieved[0]["final_retrieval"]:
                 context += retrieved[0]["final_retrieval"][x]
             context = ["\n".join(set(context))]
+            resp = self._generate_response(question, context, verbose=verbose)
         else:
             context = ["\n".join(retrieved[0]["final_retrieval"][x]) for x in retrieved[0]["final_retrieval"]]
-
-        with ThreadPoolExecutor() as executor:
-            res = executor.submit(self.gather_candidates, question, context).result()
-
-        # sort list by quality score
-        res.sort(key=lambda x: x.quality_score, reverse=True)
-
-        new_context = [{"candidate_answer": x.answer,
-                        "score": x.quality_score} for x in res[:top_k]]
-        
-        resp = self._generate_response(question, new_context, verbose=verbose)
+            new_context = self._score_candidates(question, context, top_k=top_k)
+            resp = self._generate_response(question, new_context, verbose=verbose)
 
         if verbose and len(retrieved) > 1 and "verbose" in retrieved[1]:
             resp["verbose"] = retrieved[1]["verbose"]
diff --git a/graphrag/app/supportai/retrievers/HybridRetriever.py b/graphrag/app/supportai/retrievers/HybridRetriever.py
index dfff512..e21d0c1 100644
--- a/graphrag/app/supportai/retrievers/HybridRetriever.py
+++ b/graphrag/app/supportai/retrievers/HybridRetriever.py
@@ -88,15 +88,16 @@ def search(self, question, indices, top_k=1, similarity_threshold=0.90, num_hops
     def retrieve_answer(self, question, index, top_k=1, similarity_threshold=0.90, num_hops=2, num_seen_min=1, expand: bool = False, method: str = "similarity", chunk_only: bool = False, doc_only: bool = False, combine: bool = False, verbose: bool = False):
         retrieved = self.search(question, index, top_k, similarity_threshold, num_hops, num_seen_min, expand, method, chunk_only, doc_only, verbose)
 
-        context = []
         if combine:
+            context = []
             for x in retrieved[0]["final_retrieval"]:
                 context += retrieved[0]["final_retrieval"][x]
             context = ["\n".join(set(context))]
+            resp = self._generate_response(question, context, verbose=verbose)
         else:
             context = ["\n".join(retrieved[0]["final_retrieval"][x]) for x in retrieved[0]["final_retrieval"]]
-
-        resp = self._generate_response(question, context, verbose=verbose)
+            scored = self._score_candidates(question, context, top_k=top_k)
+            resp = self._generate_response(question, scored, verbose=verbose)
         
         if verbose and len(retrieved) > 1 and "verbose" in retrieved[1]:
             resp["verbose"] = retrieved[1]["verbose"]
diff --git a/graphrag/app/supportai/retrievers/SiblingRetriever.py b/graphrag/app/supportai/retrievers/SiblingRetriever.py
index 903162d..2e66f01 100644
--- a/graphrag/app/supportai/retrievers/SiblingRetriever.py
+++ b/graphrag/app/supportai/retrievers/SiblingRetriever.py
@@ -70,8 +70,10 @@ def retrieve_answer(
         context = ["\n".join(content[x]) for x in content]
         if combine:
             context = ["\n ".join(context)]
-
-        resp = self._generate_response(question, context, verbose=verbose)
+            resp = self._generate_response(question, context, verbose=verbose)
+        else:
+            scored = self._score_candidates(question, context, top_k=top_k)
+            resp = self._generate_response(question, scored, verbose=verbose)
 
         if verbose and len(retrieved) > 1 and "verbose" in retrieved[1]:
             resp["verbose"] = retrieved[1]["verbose"]
diff --git a/graphrag/app/supportai/retrievers/SimilarityRetriever.py b/graphrag/app/supportai/retrievers/SimilarityRetriever.py
index 22611a7..e5f948c 100644
--- a/graphrag/app/supportai/retrievers/SimilarityRetriever.py
+++ b/graphrag/app/supportai/retrievers/SimilarityRetriever.py
@@ -60,8 +60,10 @@ def retrieve_answer(self, question, index, top_k=1, withHyDE=False, expand=False
         context = [retrieved[0]["final_retrieval"][x] for x in retrieved[0]["final_retrieval"]]
         if combine:
             context = ["\n".join(context)]
-
-        resp = self._generate_response(question, context, verbose=verbose)
+            resp = self._generate_response(question, context, verbose=verbose)
+        else:
+            scored = self._score_candidates(question, context, top_k=top_k)
+            resp = self._generate_response(question, scored, verbose=verbose)
 
         if verbose and len(retrieved) > 1 and "verbose" in retrieved[1]:
             resp["verbose"] = retrieved[1]["verbose"]
diff --git a/graphrag/app/tools/generate_cypher.py b/graphrag/app/tools/generate_cypher.py
index 34cd1b1..8e7ffcb 100644
--- a/graphrag/app/tools/generate_cypher.py
+++ b/graphrag/app/tools/generate_cypher.py
@@ -14,7 +14,6 @@
 
 import logging
 from typing import Iterable
-from langchain_community.callbacks.manager import get_openai_callback
 from langchain_core.output_parsers import StrOutputParser
 from langchain.prompts import PromptTemplate
 from langchain.tools import BaseTool
@@ -121,16 +120,17 @@ def generate_cypher(self, question: str, history: Iterable[str]) -> str:
         schema = self._generate_schema_rep()
         logger.debug_pii("Prompt to LLM:\n" + PROMPT.invoke({"question": question, "schema": schema, "history": history}).to_string())
 
-        chain = PROMPT | self.llm.model | StrOutputParser()
-        usage_data = {}
-        with get_openai_callback() as cb:
-            out = chain.invoke({"question": question, "schema": schema, "history": history}).strip("```cypher").strip("```")
+        out = self.llm.invoke_with_parser(
+            PROMPT, StrOutputParser(),
+            {"question": question, "schema": schema, "history": history},
+            caller_name="generate_cypher",
+        ).strip("```cypher").strip("```").strip()
 
-            usage_data["input_tokens"] = cb.prompt_tokens
-            usage_data["output_tokens"] = cb.completion_tokens
-            usage_data["total_tokens"] = cb.total_tokens
-            usage_data["cost"] = cb.total_cost
-            logger.info(f"generate_cypher usage: {usage_data}")
+        # Validate the LLM output looks like a Cypher query
+        out_upper = out.upper()
+        if not any(kw in out_upper for kw in ("MATCH", "RETURN", "WITH", "UNWIND", "CALL")):
+            LogWriter.info(f"request_id={req_id_cv.get()} EXIT generate_cypher - LLM did not produce a valid Cypher query")
+            raise ValueError(f"LLM did not produce a valid Cypher query: {out[:200]}")
 
         query_header = "USE GRAPH " + self.conn.graphname + " "+ "\n" + "INTERPRET OPENCYPHER QUERY () {" + "\n"
         query_footer = "\n}"
diff --git a/graphrag/app/tools/generate_function.py b/graphrag/app/tools/generate_function.py
index 195a554..9801000 100644
--- a/graphrag/app/tools/generate_function.py
+++ b/graphrag/app/tools/generate_function.py
@@ -21,7 +21,6 @@
 from langchain.prompts import PromptTemplate
 from langchain.tools import BaseTool
 from langchain.tools.base import ToolException
-from langchain_community.callbacks.manager import get_openai_callback
 
 from common.embeddings.base_embedding_store import EmbeddingStore
 from common.embeddings.embedding_services import EmbeddingModel
@@ -200,16 +199,10 @@ def _run(
 
         logger.debug(f"request_id={req_id_cv.get()} retrieved documents={docs}")
 
-        chain = PROMPT | self.llm.model | func_parser
-        usage_data = {}
-        with get_openai_callback() as cb:
-            generated = chain.invoke(**inputs)
-
-            usage_data["input_tokens"] = cb.prompt_tokens
-            usage_data["output_tokens"] = cb.completion_tokens
-            usage_data["total_tokens"] = cb.total_tokens
-            usage_data["cost"] = cb.total_cost
-            logger.info(f"generate_function usage: {usage_data}")
+        generated = self.llm.invoke_with_parser(
+            PROMPT, func_parser,
+            inputs, caller_name="generate_function",
+        )
 
         logger.debug(f"request_id={req_id_cv.get()} generated function")
         try:
diff --git a/graphrag/app/tools/generate_gsql.py b/graphrag/app/tools/generate_gsql.py
index 8e60a98..5afc42c 100644
--- a/graphrag/app/tools/generate_gsql.py
+++ b/graphrag/app/tools/generate_gsql.py
@@ -14,7 +14,6 @@
 
 import logging
 from typing import Iterable
-from langchain_community.callbacks.manager import get_openai_callback
 from langchain_core.output_parsers import StrOutputParser
 from langchain.prompts import PromptTemplate
 from langchain.tools import BaseTool
@@ -124,16 +123,17 @@ def generate_gsql(self, question: str, history: Iterable[str]) -> str:
 
         logger.debug_pii("Prompt to LLM:\n" + PROMPT.invoke({"question": question, "schema": schema, "history": history}).to_string())
 
-        chain = PROMPT | self.llm.model | StrOutputParser()
-        usage_data = {}
-        with get_openai_callback() as cb:
-            out = chain.invoke({"question": question, "schema": schema, "history": history}).strip("```gsql").strip("```")
+        out = self.llm.invoke_with_parser(
+            PROMPT, StrOutputParser(),
+            {"question": question, "schema": schema, "history": history},
+            caller_name="generate_gsql",
+        ).strip("```gsql").strip("```").strip()
 
-            usage_data["input_tokens"] = cb.prompt_tokens
-            usage_data["output_tokens"] = cb.completion_tokens
-            usage_data["total_tokens"] = cb.total_tokens
-            usage_data["cost"] = cb.total_cost
-            logger.info(f"generate_gsql usage: {usage_data}")
+        # Validate the LLM output looks like a GSQL query
+        out_upper = out.upper()
+        if not any(kw in out_upper for kw in ("SELECT", "FROM", "WHERE", "ACCUM", "INSTALL", "CREATE", "INTERPRET")):
+            LogWriter.info(f"request_id={req_id_cv.get()} EXIT generate_gsql - LLM did not produce a valid GSQL query")
+            raise ValueError(f"LLM did not produce a valid GSQL query: {out[:200]}")
 
         gsql = "USE GRAPH " + self.conn.graphname + " "+ "\n" + out + "\n"
         LogWriter.info(f"request_id={req_id_cv.get()} EXIT generate_gsql with:\n{gsql}")
diff --git a/graphrag/app/tools/map_question_to_schema.py b/graphrag/app/tools/map_question_to_schema.py
index b182397..b9dbd90 100644
--- a/graphrag/app/tools/map_question_to_schema.py
+++ b/graphrag/app/tools/map_question_to_schema.py
@@ -17,7 +17,6 @@
 from langchain.llms.base import LLM
 from langchain.prompts import PromptTemplate
 from langchain_core.output_parsers import PydanticOutputParser
-from langchain_community.callbacks.manager import get_openai_callback
 
 from common.metrics.tg_proxy import TigerGraphConnectionProxy
 from common.py_schemas import MapQuestionToSchemaResponse, MapAttributeToAttributeResponse
@@ -93,8 +92,6 @@ def _run(self, query: str, conversation: List[Dict[str, str]]) -> str:
             partial_variables={"format_instructions": parser.get_format_instructions()},
         )
 
-        restate_chain = RESTATE_QUESTION_PROMPT | self.llm.model | parser
-
         schema_ver = get_schema_ver(self.conn)
         if schema_ver is None or self.schema_ver != schema_ver:
             self.schema_ver = schema_ver if schema_ver is not None else -1
@@ -115,22 +112,18 @@ def _run(self, query: str, conversation: List[Dict[str, str]]) -> str:
         else:
             logger.info(f"Reusing existing schema rep for schema version {schema_ver}")
 
-        usage_data = {}
-        with get_openai_callback() as cb:
-            parsed_q = restate_chain.invoke(
-                {
-                    "vertices": self.vertices,
-                    "verticesAttrs": self.vertices_info,
-                    "edges": self.edges,
-                    "edgesInfo": self.edges_info,
-                    "question": query,
-                    "conversation": conversation,
-                }
-            )
-            usage_data["input_tokens"] = cb.prompt_tokens
-            usage_data["output_tokens"] = cb.completion_tokens
-            usage_data["total_tokens"] = cb.total_tokens
-            usage_data["cost"] = cb.total_cost
+        parsed_q = self.llm.invoke_with_parser(
+            RESTATE_QUESTION_PROMPT, parser,
+            {
+                "vertices": self.vertices,
+                "verticesAttrs": self.vertices_info,
+                "edges": self.edges,
+                "edgesInfo": self.edges_info,
+                "question": query,
+                "conversation": conversation,
+            },
+            caller_name="map_question_to_schema",
+        )
         # logger.info(f"parsed_q: {parsed_q}")
 
         logger.debug_pii(
@@ -153,20 +146,16 @@ def _run(self, query: str, conversation: List[Dict[str, str]]) -> str:
             },
         )
 
-        attr_map_chain = ATTR_MAP_PROMPT | self.llm.model | attr_parser
         if parsed_q.target_vertex_attributes:
             for vertex in parsed_q.target_vertex_attributes.keys():
-                with get_openai_callback() as cb:
-                    parsed_map = attr_map_chain.invoke(
-                        {
-                            "parsed_attrs": parsed_q.target_vertex_attributes[vertex],
-                            "real_attrs": [attr[0] for attr in self.conn.getVertexAttrs(vertex)],
-                        }
-                    ).attr_map
-                    usage_data["input_tokens"] += cb.prompt_tokens
-                    usage_data["output_tokens"] += cb.completion_tokens
-                    usage_data["total_tokens"] += cb.total_tokens
-                    usage_data["cost"] += cb.total_cost
+                parsed_map = self.llm.invoke_with_parser(
+                    ATTR_MAP_PROMPT, attr_parser,
+                    {
+                        "parsed_attrs": parsed_q.target_vertex_attributes[vertex],
+                        "real_attrs": [attr[0] for attr in self.conn.getVertexAttrs(vertex)],
+                    },
+                    caller_name="map_vertex_attributes",
+                ).attr_map
                 if parsed_map:
                     parsed_q.target_vertex_attributes[vertex] = [
                         parsed_map.get(x) for x in list(parsed_q.target_vertex_attributes[vertex])
@@ -176,17 +165,14 @@ def _run(self, query: str, conversation: List[Dict[str, str]]) -> str:
 
         if parsed_q.target_edge_attributes:
             for edge in parsed_q.target_edge_attributes.keys():
-                with get_openai_callback() as cb:
-                    parsed_map = attr_map_chain.invoke(
-                        {
-                            "parsed_attrs": parsed_q.target_edge_attributes[edge],
-                            "real_attrs": self.conn.getEdgeAttrs(edge),
-                        }
-                    ).attr_map
-                    usage_data["input_tokens"] += cb.prompt_tokens
-                    usage_data["output_tokens"] += cb.completion_tokens
-                    usage_data["total_tokens"] += cb.total_tokens
-                    usage_data["cost"] += cb.total_cost
+                parsed_map = self.llm.invoke_with_parser(
+                    ATTR_MAP_PROMPT, attr_parser,
+                    {
+                        "parsed_attrs": parsed_q.target_edge_attributes[edge],
+                        "real_attrs": self.conn.getEdgeAttrs(edge),
+                    },
+                    caller_name="map_edge_attributes",
+                ).attr_map
                 if parsed_map:
                     parsed_q.target_edge_attributes[edge] = [
                         parsed_map[x] for x in list(parsed_q.target_edge_attributes[edge])
@@ -194,8 +180,6 @@ def _run(self, query: str, conversation: List[Dict[str, str]]) -> str:
 
             logger.debug(f"request_id={req_id_cv.get()} MapEdgeAttributes applied")
 
-        logger.info(f"map_question_to_schema usage: {usage_data}")
-
         try:
             validate_schema(
                 self.conn,
diff --git a/graphrag/tests/__pycache__/conftest.cpython-313-pytest-9.0.2.pyc b/graphrag/tests/__pycache__/conftest.cpython-313-pytest-9.0.2.pyc
new file mode 100644
index 0000000..4f472eb
Binary files /dev/null and b/graphrag/tests/__pycache__/conftest.cpython-313-pytest-9.0.2.pyc differ
diff --git a/graphrag/tests/__pycache__/test_connections.cpython-313-pytest-9.0.2.pyc b/graphrag/tests/__pycache__/test_connections.cpython-313-pytest-9.0.2.pyc
new file mode 100644
index 0000000..42fb1dd
Binary files /dev/null and b/graphrag/tests/__pycache__/test_connections.cpython-313-pytest-9.0.2.pyc differ
diff --git a/graphrag/tests/test_invoke_with_parser.py b/graphrag/tests/test_invoke_with_parser.py
new file mode 100644
index 0000000..5e1d52b
--- /dev/null
+++ b/graphrag/tests/test_invoke_with_parser.py
@@ -0,0 +1,274 @@
+# Copyright (c) 2024-2026 TigerGraph, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import asyncio
+import json
+import re
+import unittest
+from unittest.mock import MagicMock, patch, AsyncMock
+
+from langchain_core.exceptions import OutputParserException
+from langchain_core.output_parsers import PydanticOutputParser, StrOutputParser
+from langchain_core.prompts import PromptTemplate
+from pydantic import BaseModel, Field
+
+from common.llm_services.base_llm import LLM_Model
+
+
+class SampleResponse(BaseModel):
+    answer: str = Field(description="The answer")
+    score: int = Field(description="Quality score")
+
+
+def _make_llm_model():
+    """Create an LLM_Model with a mocked LLM."""
+    config = {"prompt_path": ""}
+    model = LLM_Model(config)
+    model.llm = MagicMock()
+    return model
+
+
+def _make_prompt():
+    return PromptTemplate(
+        template="Question: {question}\n{format_instructions}",
+        input_variables=["question"],
+        partial_variables={
+            "format_instructions": PydanticOutputParser(
+                pydantic_object=SampleResponse
+            ).get_format_instructions()
+        },
+    )
+
+
+def _setup_chain_mock(model, raw_content, mock_cb_ctx, async_mode=False):
+    """Set up mock chain invocation with callback context."""
+    mock_output = MagicMock()
+    mock_output.content = raw_content
+
+    mock_cb = MagicMock()
+    mock_cb.prompt_tokens = 10
+    mock_cb.completion_tokens = 5
+    mock_cb.total_tokens = 15
+    mock_cb.total_cost = 0.001
+    mock_cb_ctx.return_value.__enter__ = MagicMock(return_value=mock_cb)
+    mock_cb_ctx.return_value.__exit__ = MagicMock(return_value=False)
+
+    mock_chain = MagicMock()
+    if async_mode:
+        mock_chain.ainvoke = AsyncMock(return_value=mock_output)
+    else:
+        mock_chain.invoke.return_value = mock_output
+
+    # patch prompt.__or__ so that (prompt | self.llm) returns mock_chain
+    return mock_chain
+
+
+class TestInvokeWithParser(unittest.TestCase):
+    """Tests for LLM_Model.invoke_with_parser."""
+
+    @patch("common.llm_services.base_llm.get_openai_callback")
+    def test_clean_json_parses_directly(self, mock_cb_ctx):
+        """When LLM returns clean JSON, parser succeeds on first attempt."""
+        model = _make_llm_model()
+        prompt = _make_prompt()
+        parser = PydanticOutputParser(pydantic_object=SampleResponse)
+
+        raw_json = '{"answer": "hello", "score": 95}'
+        mock_chain = _setup_chain_mock(model, raw_json, mock_cb_ctx)
+
+        with patch.object(type(prompt), "__or__", return_value=mock_chain):
+            result = model.invoke_with_parser(
+                prompt, parser, {"question": "test"}, caller_name="test_clean"
+            )
+        self.assertEqual(result.answer, "hello")
+        self.assertEqual(result.score, 95)
+
+    @patch("common.llm_services.base_llm.get_openai_callback")
+    def test_preamble_text_falls_back_to_regex(self, mock_cb_ctx):
+        """When LLM wraps JSON with preamble text, regex fallback extracts it."""
+        model = _make_llm_model()
+        prompt = _make_prompt()
+        parser = PydanticOutputParser(pydantic_object=SampleResponse)
+
+        raw_text = 'Here is the result:\n{"answer": "world", "score": 80}\nHope this helps!'
+        mock_chain = _setup_chain_mock(model, raw_text, mock_cb_ctx)
+
+        with patch.object(type(prompt), "__or__", return_value=mock_chain):
+            result = model.invoke_with_parser(
+                prompt, parser, {"question": "test"}, caller_name="test_preamble"
+            )
+        self.assertEqual(result.answer, "world")
+        self.assertEqual(result.score, 80)
+
+    @patch("common.llm_services.base_llm.get_openai_callback")
+    def test_no_json_raises_exception(self, mock_cb_ctx):
+        """When LLM returns no JSON at all, raises OutputParserException."""
+        model = _make_llm_model()
+        prompt = _make_prompt()
+        parser = PydanticOutputParser(pydantic_object=SampleResponse)
+
+        mock_chain = _setup_chain_mock(
+            model, "I cannot answer this question.", mock_cb_ctx
+        )
+
+        with patch.object(type(prompt), "__or__", return_value=mock_chain):
+            with self.assertRaises(OutputParserException):
+                model.invoke_with_parser(
+                    prompt, parser, {"question": "test"}, caller_name="test_no_json"
+                )
+
+    @patch("common.llm_services.base_llm.get_openai_callback")
+    def test_str_output_parser(self, mock_cb_ctx):
+        """StrOutputParser returns raw text without JSON parsing."""
+        model = _make_llm_model()
+        prompt = PromptTemplate(
+            template="Generate query for: {question}",
+            input_variables=["question"],
+        )
+        parser = StrOutputParser()
+
+        raw_text = "SELECT * FROM table WHERE id = 1"
+        mock_chain = _setup_chain_mock(model, raw_text, mock_cb_ctx)
+
+        with patch.object(type(prompt), "__or__", return_value=mock_chain):
+            result = model.invoke_with_parser(
+                prompt, parser, {"question": "test"}, caller_name="test_str"
+            )
+        self.assertEqual(result, "SELECT * FROM table WHERE id = 1")
+
+    @patch("common.llm_services.base_llm.get_openai_callback")
+    def test_usage_tracking_logged(self, mock_cb_ctx):
+        """Token usage is logged via get_openai_callback."""
+        model = _make_llm_model()
+        prompt = PromptTemplate(
+            template="{question}", input_variables=["question"]
+        )
+        parser = StrOutputParser()
+
+        mock_chain = _setup_chain_mock(model, "result", mock_cb_ctx)
+
+        with patch("common.llm_services.base_llm.logger") as mock_logger:
+            with patch.object(type(prompt), "__or__", return_value=mock_chain):
+                model.invoke_with_parser(
+                    prompt, parser, {"question": "test"}, caller_name="test_usage"
+                )
+            log_calls = [str(c) for c in mock_logger.info.call_args_list]
+            self.assertTrue(
+                any("test_usage usage" in c for c in log_calls),
+                f"Expected usage log, got: {log_calls}",
+            )
+
+
+class TestAinvokeWithParser(unittest.TestCase):
+    """Tests for LLM_Model.ainvoke_with_parser."""
+
+    @patch("common.llm_services.base_llm.get_openai_callback")
+    def test_async_clean_json(self, mock_cb_ctx):
+        """Async version parses clean JSON correctly."""
+        model = _make_llm_model()
+        prompt = _make_prompt()
+        parser = PydanticOutputParser(pydantic_object=SampleResponse)
+
+        raw_json = '{"answer": "async_hello", "score": 90}'
+        mock_chain = _setup_chain_mock(model, raw_json, mock_cb_ctx, async_mode=True)
+
+        with patch.object(type(prompt), "__or__", return_value=mock_chain):
+            result = asyncio.new_event_loop().run_until_complete(
+                model.ainvoke_with_parser(
+                    prompt, parser, {"question": "test"}, caller_name="test_async"
+                )
+            )
+        self.assertEqual(result.answer, "async_hello")
+        self.assertEqual(result.score, 90)
+
+    @patch("common.llm_services.base_llm.get_openai_callback")
+    def test_async_regex_fallback(self, mock_cb_ctx):
+        """Async version falls back to regex extraction on preamble."""
+        model = _make_llm_model()
+        prompt = _make_prompt()
+        parser = PydanticOutputParser(pydantic_object=SampleResponse)
+
+        raw_text = 'Sure!\n{"answer": "async_world", "score": 75}'
+        mock_chain = _setup_chain_mock(model, raw_text, mock_cb_ctx, async_mode=True)
+
+        with patch.object(type(prompt), "__or__", return_value=mock_chain):
+            result = asyncio.new_event_loop().run_until_complete(
+                model.ainvoke_with_parser(
+                    prompt,
+                    parser,
+                    {"question": "test"},
+                    caller_name="test_async_fallback",
+                )
+            )
+        self.assertEqual(result.answer, "async_world")
+        self.assertEqual(result.score, 75)
+
+
+def _parse_json_output(content: str) -> dict:
+    """Standalone copy of LLMEntityRelationshipExtractor._parse_json_output
+    for testing without importing the full extractor dependency chain."""
+    try:
+        return json.loads(content.strip("content="))
+    except (json.JSONDecodeError, ValueError):
+        pass
+    if "```json" in content:
+        try:
+            return json.loads(
+                content.split("```")[1].strip("```").strip("json").strip()
+            )
+        except (json.JSONDecodeError, ValueError, IndexError):
+            pass
+    match = re.search(r'\{[\s\S]*\}', content)
+    if match:
+        return json.loads(match.group())
+    raise ValueError(f"Could not extract JSON from LLM output: {content[:200]}")
+
+
+class TestParseJsonOutput(unittest.TestCase):
+    """Tests for the _parse_json_output fallback logic
+    (same algorithm used in LLMEntityRelationshipExtractor)."""
+
+    def test_direct_json(self):
+        result = _parse_json_output('{"nodes": [], "rels": []}')
+        self.assertEqual(result, {"nodes": [], "rels": []})
+
+    def test_json_code_fence(self):
+        text = 'Here is the output:\n```json\n{"nodes": [{"id": "A", "node_type": "Person", "definition": "test"}], "rels": []}\n```'
+        result = _parse_json_output(text)
+        self.assertEqual(len(result["nodes"]), 1)
+        self.assertEqual(result["nodes"][0]["id"], "A")
+
+    def test_preamble_regex_fallback(self):
+        text = 'Based on the input, I extracted:\n{"nodes": [], "rels": [{"source": "A", "target": "B", "relation_type": "knows", "definition": ""}]}'
+        result = _parse_json_output(text)
+        self.assertEqual(len(result["rels"]), 1)
+
+    def test_nested_json(self):
+        text = '{"nodes": [{"id": "X", "node_type": "Org", "definition": "a company"}], "rels": [{"source": {"id": "X"}, "target": "Y", "relation_type": "owns", "definition": ""}]}'
+        result = _parse_json_output(text)
+        self.assertEqual(result["nodes"][0]["id"], "X")
+        self.assertIsInstance(result["rels"][0]["source"], dict)
+
+    def test_no_json_raises(self):
+        with self.assertRaises((ValueError, json.JSONDecodeError)):
+            _parse_json_output("No JSON content here at all")
+
+    def test_preamble_before_code_fence(self):
+        text = 'Let me extract the entities for you:\n```json\n{"nodes": [{"id": "B", "node_type": "City", "definition": "a city"}], "rels": []}\n```\nDone!'
+        result = _parse_json_output(text)
+        self.assertEqual(result["nodes"][0]["id"], "B")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/graphrag/tests/test_ui_setup_integration.py b/graphrag/tests/test_ui_setup_integration.py
new file mode 100644
index 0000000..76f2772
--- /dev/null
+++ b/graphrag/tests/test_ui_setup_integration.py
@@ -0,0 +1,236 @@
+# Copyright (c) 2024-2026 TigerGraph, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+import os
+import unittest
+
+import pytest
+import requests
+
+
+# Base URL of the running GraphRAG service. Override via env var when running
+# against a non-default host/port (e.g. GRAPHRAG_URL=http://localhost:8000).
+GRAPHRAG_URL = os.getenv("GRAPHRAG_URL", "http://localhost:80")
+
+# Credentials loaded from DB_CONFIG (same pattern as test_supportai.py).
+_db_config_path = os.getenv("DB_CONFIG", "./configs/db_config.json")
+try:
+    with open(_db_config_path) as _f:
+        _db = json.load(_f)
+    SUPERUSER = _db.get("username", "tigergraph")
+    SUPERUSER_PASSWORD = _db.get("password", "tigergraph")
+except Exception:
+    SUPERUSER = os.getenv("TG_USERNAME", "tigergraph")
+    SUPERUSER_PASSWORD = os.getenv("TG_PASSWORD", "tigergraph")
+
+# A graph-admin user that exists on the running TigerGraph instance.
+# Override via env vars when your test graph/user differ.
+GRAPH_ADMIN_USER = os.getenv("GRAPH_ADMIN_USER", SUPERUSER)
+GRAPH_ADMIN_PASSWORD = os.getenv("GRAPH_ADMIN_PASSWORD", SUPERUSER_PASSWORD)
+GRAPH_ADMIN_GRAPH = os.getenv("GRAPH_ADMIN_GRAPH", "MyGraph")
+
+
+@pytest.mark.skipif(not os.getenv("GRAPHRAG_URL"), reason="Integration tests require a live GraphRAG service. Set GRAPHRAG_URL to run.")
+class TestUISetupIntegration(unittest.TestCase):
+    """
+    Integration tests for /ui/config and /ui/config/db/test.
+    These hit the actual running GraphRAG service over HTTP and require:
+      - A live TigerGraph + GraphRAG stack (docker-compose up)
+      - GRAPHRAG_URL pointing at the service (default: http://localhost:80)
+      - DB_CONFIG or TG_USERNAME / TG_PASSWORD env vars with valid superuser creds
+
+    Run from outside Docker:
+        GRAPHRAG_URL=http://localhost:80 python -m pytest tests/test_ui_setup_integration.py -v
+
+    Test map
+    --------
+      1. test_superuser_can_save_and_retrieve_llm_config
+      2. test_graph_admin_chatbot_only_access
+      3. test_db_connection_valid_and_invalid_creds
+      4. test_graph_admin_chat_service_save_and_inherit
+    """
+
+    # =========================================================================
+    # Test 1 – Superuser saves full LLM config and the values persist
+    # =========================================================================
+
+    def test_superuser_can_save_and_retrieve_llm_config(self):
+        """POST a new completion model name, then GET /ui/config and verify it persisted."""
+        openai_key = os.getenv("OPENAI_API_KEY", "sk-test")
+        payload = {
+            "completion_service": {
+                "llm_service": "openai",
+                "llm_model": "gpt-4o-mini",
+                "model_kwargs": {"temperature": 0},
+                "authentication_configuration": {"OPENAI_API_KEY": openai_key},
+            },
+            "embedding_service": {
+                "embedding_model_service": "openai",
+                "model_name": "text-embedding-3-small",
+                "authentication_configuration": {"OPENAI_API_KEY": openai_key},
+            },
+        }
+        post_resp = requests.post(
+            f"{GRAPHRAG_URL}/ui/config/llm",
+            json=payload,
+            auth=(SUPERUSER, SUPERUSER_PASSWORD),
+        )
+        self.assertEqual(post_resp.status_code, 200, post_resp.text)
+        self.assertEqual(post_resp.json().get("status"), "success")
+
+        get_resp = requests.get(
+            f"{GRAPHRAG_URL}/ui/config",
+            auth=(SUPERUSER, SUPERUSER_PASSWORD),
+        )
+        self.assertEqual(get_resp.status_code, 200, get_resp.text)
+        completion = get_resp.json().get("llm_config", {}).get("completion_service", {})
+        self.assertEqual(completion.get("llm_model"), "gpt-4o-mini")
+
+    # =========================================================================
+    # Test 2 – Graph admin: 403 on full config, success on chat_service
+    # =========================================================================
+
+    def test_graph_admin_chatbot_only_access(self):
+        """Graph admin cannot POST a full LLM config (403) but can POST chat_service."""
+        if GRAPH_ADMIN_USER == SUPERUSER:
+            self.skipTest(
+                "GRAPH_ADMIN_USER is the same as SUPERUSER — set GRAPH_ADMIN_USER "
+                "and GRAPH_ADMIN_PASSWORD env vars to a graph-level admin to run this test."
+            )
+        full_payload = {
+            "completion_service": {
+                "llm_service": "openai",
+                "llm_model": "gpt-4o",
+                "authentication_configuration": {"OPENAI_API_KEY": "sk-test"},
+            }
+        }
+        resp_full = requests.post(
+            f"{GRAPHRAG_URL}/ui/config/llm",
+            json=full_payload,
+            auth=(GRAPH_ADMIN_USER, GRAPH_ADMIN_PASSWORD),
+        )
+        self.assertEqual(resp_full.status_code, 403, resp_full.text)
+
+        chatbot_payload = {
+            "graphname": GRAPH_ADMIN_GRAPH,
+            "chat_service": {
+                "llm_model": "gpt-4o-mini",
+            },
+        }
+        resp_chatbot = requests.post(
+            f"{GRAPHRAG_URL}/ui/config/llm",
+            json=chatbot_payload,
+            auth=(GRAPH_ADMIN_USER, GRAPH_ADMIN_PASSWORD),
+        )
+        self.assertEqual(resp_chatbot.status_code, 200, resp_chatbot.text)
+        self.assertEqual(resp_chatbot.json().get("status"), "success")
+
+    # =========================================================================
+    # Test 4 – Graph admin: save custom chat_service and revert to inherit
+    # =========================================================================
+
+    def test_graph_admin_chat_service_save_and_inherit(self):
+        """Graph admin saves a custom chat_service, verifies it in GET, then reverts to inherit."""
+        if GRAPH_ADMIN_USER == SUPERUSER:
+            self.skipTest(
+                "GRAPH_ADMIN_USER is the same as SUPERUSER — set GRAPH_ADMIN_USER "
+                "and GRAPH_ADMIN_PASSWORD env vars to a graph-level admin to run this test."
+            )
+        # Save custom chat_service
+        save_payload = {
+            "graphname": GRAPH_ADMIN_GRAPH,
+            "chat_service": {
+                "llm_service": "openai",
+                "llm_model": "gpt-4o-mini",
+                "model_kwargs": {"temperature": 0.5},
+            },
+        }
+        resp_save = requests.post(
+            f"{GRAPHRAG_URL}/ui/config/llm",
+            json=save_payload,
+            auth=(GRAPH_ADMIN_USER, GRAPH_ADMIN_PASSWORD),
+        )
+        self.assertEqual(resp_save.status_code, 200, resp_save.text)
+
+        # GET should return the custom config (without auth secrets)
+        resp_get = requests.get(
+            f"{GRAPHRAG_URL}/ui/config?graphname={GRAPH_ADMIN_GRAPH}",
+            auth=(GRAPH_ADMIN_USER, GRAPH_ADMIN_PASSWORD),
+        )
+        self.assertEqual(resp_get.status_code, 200, resp_get.text)
+        data = resp_get.json()
+        self.assertEqual(data.get("llm_config_access"), "chatbot_only")
+        self.assertIsNotNone(data.get("chatbot_config"), "chatbot_config should be present after save")
+        self.assertEqual(data["chatbot_config"].get("llm_model"), "gpt-4o-mini")
+        self.assertNotIn("authentication_configuration", data.get("chatbot_config", {}))
+        self.assertIn("global_chat_info", data)
+
+        # Revert to inherit by sending null chat_service
+        revert_payload = {
+            "graphname": GRAPH_ADMIN_GRAPH,
+            "chat_service": None,
+        }
+        resp_revert = requests.post(
+            f"{GRAPHRAG_URL}/ui/config/llm",
+            json=revert_payload,
+            auth=(GRAPH_ADMIN_USER, GRAPH_ADMIN_PASSWORD),
+        )
+        self.assertEqual(resp_revert.status_code, 200, resp_revert.text)
+
+        # GET should now show chatbot_config as None (inheriting)
+        resp_get2 = requests.get(
+            f"{GRAPHRAG_URL}/ui/config?graphname={GRAPH_ADMIN_GRAPH}",
+            auth=(GRAPH_ADMIN_USER, GRAPH_ADMIN_PASSWORD),
+        )
+        self.assertEqual(resp_get2.status_code, 200, resp_get2.text)
+        self.assertIsNone(resp_get2.json().get("chatbot_config"))
+
+    # =========================================================================
+    # Test 3 – DB connection test: valid creds succeed, invalid creds fail cleanly
+    # =========================================================================
+
+    def test_db_connection_valid_and_invalid_creds(self):
+        """POST /ui/config/db/test returns success for valid creds and error (not 500) for invalid."""
+        valid_payload = {
+            "hostname": os.getenv("TG_HOST", "http://tigergraph"),
+            "username": SUPERUSER,
+            "password": SUPERUSER_PASSWORD,
+            "gsPort": os.getenv("TG_GS_PORT", "14240"),
+            "restppPort": os.getenv("TG_RESTPP_PORT", "9000"),
+        }
+        valid_resp = requests.post(
+            f"{GRAPHRAG_URL}/ui/config/db/test",
+            json=valid_payload,
+            auth=(SUPERUSER, SUPERUSER_PASSWORD),
+        )
+        self.assertEqual(valid_resp.status_code, 200, valid_resp.text)
+        self.assertEqual(valid_resp.json().get("status"), "success")
+        self.assertIn("Connection successful", valid_resp.json().get("message", ""))
+
+        invalid_payload = {**valid_payload, "username": "wrong-user", "password": "wrong-pass"}
+        invalid_resp = requests.post(
+            f"{GRAPHRAG_URL}/ui/config/db/test",
+            json=invalid_payload,
+            auth=(SUPERUSER, SUPERUSER_PASSWORD),
+        )
+        self.assertEqual(invalid_resp.status_code, 200, invalid_resp.text)
+        body = invalid_resp.json()
+        self.assertEqual(body.get("status"), "error")
+        self.assertIn("Connection failed", body.get("message", ""))
+        self.assertNotIn("Traceback", body.get("message", ""))
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/graphrag/tests/test_ui_setup_unit.py b/graphrag/tests/test_ui_setup_unit.py
new file mode 100644
index 0000000..364680c
--- /dev/null
+++ b/graphrag/tests/test_ui_setup_unit.py
@@ -0,0 +1,232 @@
+# Copyright (c) 2024-2026 TigerGraph, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import sys
+import unittest
+from unittest.mock import AsyncMock, MagicMock, patch
+
+from fastapi import HTTPException
+from fastapi.security import HTTPBasicCredentials
+from fastapi.testclient import TestClient
+from app.main import app
+
+# main.py uses `import routers` (absolute), so the module is registered as
+# "routers.ui" in sys.modules.  We alias it to "app.routers.ui" so that all
+# @patch() targets resolve to the same module object.  If app/main.py ever
+# changes its import style, this alias must be updated accordingly.
+sys.modules.setdefault("app.routers.ui", sys.modules["routers.ui"])
+
+from app.routers.ui import _resolve_llm_config_access, _require_prompt_access
+
+
+def _creds(username: str = "testuser", password: str = "testpass") -> HTTPBasicCredentials:
+    return HTTPBasicCredentials(username=username, password=password)
+
+
+class TestUISetupUnit(unittest.TestCase):
+    """
+    Unit tests for /ui/config and /ui/prompts endpoint logic.
+    All TigerGraph and LLM calls are mocked — no live service required.
+
+    Test map
+    --------
+    _resolve_llm_config_access (3)
+      1. test_resolve_llm_access_superuser_returns_full
+      2. test_resolve_llm_access_graph_admin_returns_chatbot_only
+      3. test_resolve_llm_access_globalobserver_raises_403
+
+    GET /ui/config secret stripping (3)
+      4. test_get_config_strips_db_password
+      5. test_get_config_strips_llm_api_keys
+      8. test_get_config_strips_chat_service_api_keys
+
+    GET /ui/config chatbot_only response (1)
+      9. test_get_config_chatbot_only_returns_global_chat_info
+
+    _require_prompt_access (1)
+      6. test_graph_admin_entity_extraction_prompt_raises_403
+
+    Concurrent save (1)
+      7. test_concurrent_llm_save_returns_409
+    """
+
+    def setUp(self):
+        self.client = TestClient(app)
+
+    # =========================================================================
+    # Test 1 – _resolve_llm_config_access returns "full" for superuser
+    # =========================================================================
+
+    @patch("app.routers.ui._get_user_role_details", return_value=(["superuser"], {}))
+    def test_resolve_llm_access_superuser_returns_full(self, _mock):
+        result = _resolve_llm_config_access(_creds(), graphname=None)
+        self.assertEqual(result, "full")
+
+    # =========================================================================
+    # Test 2 – _resolve_llm_config_access returns "chatbot_only" for graph admin
+    # =========================================================================
+
+    @patch("app.routers.ui._get_user_role_details", return_value=([], {"mygraph": ["admin"]}))
+    def test_resolve_llm_access_graph_admin_returns_chatbot_only(self, _mock):
+        result = _resolve_llm_config_access(_creds(), graphname="mygraph")
+        self.assertEqual(result, "chatbot_only")
+
+    # =========================================================================
+    # Test 3 – _resolve_llm_config_access raises 403 for globalobserver
+    # =========================================================================
+
+    @patch("app.routers.ui._get_user_role_details", return_value=(["globalobserver"], {}))
+    def test_resolve_llm_access_globalobserver_raises_403(self, _mock):
+        with self.assertRaises(HTTPException) as ctx:
+            _resolve_llm_config_access(_creds(), graphname=None)
+        self.assertEqual(ctx.exception.status_code, 403)
+
+    # =========================================================================
+    # Test 4 – GET /ui/config does NOT return db password
+    # =========================================================================
+
+    @patch("app.routers.ui._get_user_role_details", return_value=(["superuser"], {}))
+    @patch(
+        "app.routers.ui.db_config",
+        {"hostname": "http://test-db", "username": "tigergraph", "password": "super-secret"},
+    )
+    @patch("app.routers.ui.llm_config", {"completion_service": {"llm_service": "openai"}})
+    @patch("app.routers.ui.graphrag_config", {})
+    def test_get_config_strips_db_password(self, _mock):
+        response = self.client.get("/ui/config", auth=("testuser", "testpass"))
+        self.assertEqual(response.status_code, 200)
+        db = response.json().get("db_config", {})
+        self.assertNotIn("password", db, "'password' must not be returned in db_config")
+
+    # =========================================================================
+    # Test 5 – GET /ui/config does NOT return LLM API keys
+    # =========================================================================
+
+    @patch("app.routers.ui._get_user_role_details", return_value=(["superuser"], {}))
+    @patch(
+        "app.routers.ui.llm_config",
+        {
+            "authentication_configuration": {"OPENAI_API_KEY": "sk-top"},
+            "completion_service": {"llm_service": "openai", "authentication_configuration": {"OPENAI_API_KEY": "sk-c"}},
+            "embedding_service": {"embedding_model_service": "openai", "authentication_configuration": {"OPENAI_API_KEY": "sk-e"}},
+            "multimodal_service": {"llm_service": "openai", "authentication_configuration": {"OPENAI_API_KEY": "sk-m"}},
+        },
+    )
+    @patch("app.routers.ui.db_config", {"hostname": "http://test-db"})
+    @patch("app.routers.ui.graphrag_config", {})
+    def test_get_config_strips_llm_api_keys(self, _mock):
+        response = self.client.get("/ui/config", auth=("testuser", "testpass"))
+        self.assertEqual(response.status_code, 200)
+        llm = response.json().get("llm_config", {})
+        self.assertNotIn("authentication_configuration", llm)
+        for svc in ("completion_service", "embedding_service", "multimodal_service"):
+            self.assertNotIn(
+                "authentication_configuration",
+                llm.get(svc, {}),
+                f"authentication_configuration must not be returned in {svc}",
+            )
+
+    # =========================================================================
+    # Test 8 – GET /ui/config does NOT return chat_service API keys
+    # =========================================================================
+
+    @patch("app.routers.ui._get_user_role_details", return_value=(["superuser"], {}))
+    @patch(
+        "app.routers.ui.llm_config",
+        {
+            "authentication_configuration": {"OPENAI_API_KEY": "sk-top"},
+            "completion_service": {"llm_service": "openai"},
+            "chat_service": {"llm_service": "groq", "authentication_configuration": {"GROQ_API_KEY": "gsk-secret"}},
+        },
+    )
+    @patch("app.routers.ui.db_config", {"hostname": "http://test-db"})
+    @patch("app.routers.ui.graphrag_config", {})
+    def test_get_config_strips_chat_service_api_keys(self, _mock):
+        response = self.client.get("/ui/config", auth=("testuser", "testpass"))
+        self.assertEqual(response.status_code, 200)
+        llm = response.json().get("llm_config", {})
+        chat_svc = llm.get("chat_service", {})
+        self.assertNotIn(
+            "authentication_configuration",
+            chat_svc,
+            "authentication_configuration must not be returned in chat_service",
+        )
+
+    # =========================================================================
+    # Test 9 – GET /ui/config chatbot_only returns global_chat_info
+    # =========================================================================
+
+    @patch("app.routers.ui._get_user_role_details", return_value=([], {"mygraph": ["admin"]}))
+    @patch(
+        "app.routers.ui.llm_config",
+        {
+            "completion_service": {"llm_service": "openai", "llm_model": "gpt-4.1-mini"},
+        },
+    )
+    def test_get_config_chatbot_only_returns_global_chat_info(self, _mock):
+        response = self.client.get(
+            "/ui/config?graphname=mygraph", auth=("testuser", "testpass")
+        )
+        self.assertEqual(response.status_code, 200)
+        data = response.json()
+        self.assertEqual(data.get("llm_config_access"), "chatbot_only")
+        self.assertIn("global_chat_info", data)
+        self.assertEqual(data["global_chat_info"]["llm_service"], "openai")
+        self.assertEqual(data["global_chat_info"]["llm_model"], "gpt-4.1-mini")
+        # No graph-specific chat_service exists, so chatbot_config should be None
+        self.assertIsNone(data.get("chatbot_config"))
+
+    # =========================================================================
+    # Test 6 – graph admin editing entity_extraction prompt raises 403
+    # =========================================================================
+
+    @patch("app.routers.ui._get_user_role_details", return_value=([], {"mygraph": ["admin"]}))
+    def test_graph_admin_entity_extraction_prompt_raises_403(self, _mock):
+        response = self.client.post(
+            "/ui/prompts",
+            json={
+                "graphname": "mygraph",
+                "prompt_type": "entity_relationship",
+                "editable_content": "Extract only the most important entities.",
+            },
+            auth=("testuser", "testpass"),
+        )
+        self.assertEqual(response.status_code, 403)
+        self.assertIn("chatbot", response.json()["detail"].lower())
+
+    # =========================================================================
+    # Test 7 – concurrent LLM save returns 409 when lock is held
+    # =========================================================================
+
+    @patch("app.routers.ui._get_user_role_details", return_value=(["superuser"], {}))
+    @patch("app.routers.ui.auth", return_value=([], MagicMock()))
+    @patch("app.routers.ui._ecc_jobs_running", return_value=False)
+    def test_concurrent_llm_save_returns_409(self, _mock_ecc, _mock_auth, _mock_roles):
+        mock_lock = MagicMock()
+        mock_lock.locked.return_value = True
+        mock_lock.__aenter__ = AsyncMock()
+        mock_lock.__aexit__ = AsyncMock()
+
+        with patch("app.routers.ui.llm_config_lock", mock_lock):
+            response = self.client.post(
+                "/ui/config/llm",
+                json={"completion_service": {"llm_service": "openai", "llm_model": "gpt-4o"}},
+                auth=("testuser", "testpass"),
+            )
+        self.assertEqual(response.status_code, 409)
+        self.assertIn("in progress", response.json()["detail"].lower())
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/report-service/app/report_agent/agent.py b/report-service/app/report_agent/agent.py
index b04ce9f..32fd187 100644
--- a/report-service/app/report_agent/agent.py
+++ b/report-service/app/report_agent/agent.py
@@ -97,7 +97,7 @@ def generate_sections(self,
             )
 
 
-        chain = SECTION_GENERATION_PROMPT | self.llm.model | section_parser
+        chain = SECTION_GENERATION_PROMPT | self.llm.llm | section_parser
 
         if message_context:
             sections = chain.invoke({"persona": persona,
@@ -159,7 +159,7 @@ def generate_report_section(self,
             input_variables=["persona", "topic", "section_name", "section_description", "qa_pairs"],
         )
 
-        chain = SECTION_PROMPT | self.llm.model | StrOutputParser()
+        chain = SECTION_PROMPT | self.llm.llm | StrOutputParser()
         try:
             section_text = chain.invoke({"persona": persona,
                                         "topic": topic,
@@ -206,7 +206,7 @@ def finalize_report(self,
             }
         )
             
-        chain = FINALIZE_PROMPT | self.llm.model | report_parser
+        chain = FINALIZE_PROMPT | self.llm.llm | report_parser
 
         try:
             report = chain.invoke({"persona": persona,
diff --git a/report-service/app/routers/root.py b/report-service/app/routers/root.py
index bb3ae1f..2e618a2 100644
--- a/report-service/app/routers/root.py
+++ b/report-service/app/routers/root.py
@@ -5,7 +5,7 @@
 from fastapi import APIRouter, Request, Depends, Response
 from typing import Annotated
 
-from common.config import llm_config, get_llm_service
+from common.config import get_completion_config, get_llm_service
 from common.py_schemas import ReportCreationRequest
 
 from report_agent.agent import TigerGraphReportAgent
@@ -41,7 +41,7 @@ def create_report(graphname: str,
                   create_report_request: ReportCreationRequest, 
                   conn: Request, credentials: Annotated[HTTPBase, Depends(security)]):
     
-    agent = TigerGraphReportAgent(conn.state.conn, get_llm_service(llm_config))
+    agent = TigerGraphReportAgent(conn.state.conn, get_llm_service(get_completion_config()))
     sections = create_report_request.sections
     if isinstance(sections, str):
         sections = retrieve_template(sections)