diff --git a/common/config.py b/common/config.py
index 18a4288..a611594 100644
--- a/common/config.py
+++ b/common/config.py
@@ -13,9 +13,12 @@
 # limitations under the License.
 
 import json
+import logging
 import os
 
 from fastapi.security import HTTPBasic
+
+logger = logging.getLogger(__name__)
 from pyTigerGraph import TigerGraphConnection
 
 from common.embeddings.embedding_services import (
@@ -51,6 +54,34 @@
 
 # Configs
 SERVER_CONFIG = os.getenv("SERVER_CONFIG", "configs/server_config.json")
+
+
+def get_server_config_path(graphname=None):
+    """Return graph-specific server config path if it exists, else the default."""
+    if graphname:
+        graph_path = f"configs/{graphname}/server_config.json"
+        if os.path.exists(graph_path):
+            return graph_path
+    return SERVER_CONFIG
+
+
+def get_completion_config(graphname=None):
+    """
+    Return completion_service config for the given graph.
+    Uses configs/{graphname}/server_config.json if it exists, else falls back to default.
+    Auth credentials always come from the live default config so key rotations propagate.
+    """
+    config_path = get_server_config_path(graphname)
+    if config_path != SERVER_CONFIG:
+        logger.info(f"[get_completion_config] graph={graphname} using graph-specific config: {config_path}")
+        with open(config_path, "r") as f:
+            graph_config = json.load(f)
+        graph_completion = graph_config.get("llm_config", {}).get("completion_service", {}).copy()
+        if "authentication_configuration" in llm_config:
+            graph_completion["authentication_configuration"] = llm_config["authentication_configuration"]
+        return graph_completion
+    logger.info(f"[get_completion_config] graph={graphname} using default config")
+    return llm_config["completion_service"].copy()
 PATH_PREFIX = os.getenv("PATH_PREFIX", "")
 PRODUCTION = os.getenv("PRODUCTION", "false").lower() == "true"
 
@@ -83,13 +114,25 @@
 if llm_config is None:
     raise Exception("llm_config is not found in SERVER_CONFIG")
 
+# Inject authentication_configuration into service configs so they have everything they need
+if "authentication_configuration" in llm_config:
+    if "completion_service" in llm_config:
+        llm_config["completion_service"]["authentication_configuration"] = llm_config["authentication_configuration"]
+    if "embedding_service" in llm_config:
+        llm_config["embedding_service"]["authentication_configuration"] = llm_config["authentication_configuration"]
+    if "multimodal_service" in llm_config:
+        llm_config["multimodal_service"]["authentication_configuration"] = llm_config["authentication_configuration"]
+
 completion_config = llm_config.get("completion_service")
 if completion_config is None:
     raise Exception("completion_service is not found in llm_config")
-if "llm_service" not in completion_config:
-    raise Exception("llm_service is not found in completion_service")
-if "llm_model" not in completion_config:
-    raise Exception("llm_model is not found in completion_service")
+
+# Log which model will be used for chatbot and ECC/GraphRAG
+if "chatbot_llm" in completion_config:
+    logger.info(f"[CHATBOT] Using chatbot_llm: {completion_config['chatbot_llm']} (Provider: {completion_config['llm_service']})")
+    logger.info(f"[ECC/GraphRAG] Using llm_model: {completion_config['llm_model']} (Provider: {completion_config['llm_service']})")
+else:
+    logger.info(f"[CHATBOT & ECC/GraphRAG] Using llm_model: {completion_config['llm_model']} (Provider: {completion_config['llm_service']})")
 embedding_config = llm_config.get("embedding_service")
 if embedding_config is None:
     raise Exception("embedding_service is not found in llm_config")
@@ -99,6 +142,9 @@
     raise Exception("model_name is not found in embedding_service")
 embedding_dimension = embedding_config.get("dimensions", 1536)
 
+# Log which embedding model will be used
+logger.info(f"[EMBEDDING] Using model: {embedding_config.get('model_name', 'N/A')} (Provider: {embedding_config.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:
@@ -109,6 +155,8 @@
 
 # Get multimodal_service config (optional, for vision/image tasks)
 multimodal_config = llm_config.get("multimodal_service")
+if multimodal_config:
+    logger.info(f"[MULTIMODAL] Using model: {multimodal_config.get('llm_model', 'N/A')} (Provider: {multimodal_config.get('llm_service', 'N/A')})")
 
 # Merge shared authentication configuration from llm_config level into service configs
 # Services can still override by defining their own authentication_configuration
@@ -175,27 +223,44 @@
 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"])
+def get_llm_service(llm_config, for_chatbot=False) -> LLM_Model:
+    """
+    Get LLM service for either Chatbot or GraphRAG/ECC tasks.
+    
+    Args:
+        llm_config: The LLM configuration dictionary
+        for_chatbot: If True, uses chatbot_llm if specified, otherwise uses llm_model.
+                     If False (default), always uses llm_model for ECC/GraphRAG.
+    """
+    # Use completion_service which already has authentication_configuration injected
+    service_config = llm_config["completion_service"].copy()
+    
+    # For chatbot: use chatbot_llm if specified, otherwise use llm_model
+    # For ECC/GraphRAG: always use llm_model
+    if for_chatbot and "chatbot_llm" in service_config:
+        service_config["llm_model"] = service_config["chatbot_llm"]
+    # If llm_model doesn't exist, it will raise KeyError in the service constructor
+    
+    if service_config["llm_service"].lower() == "openai":
+        return OpenAI(service_config)
+    elif service_config["llm_service"].lower() == "azure":
+        return AzureOpenAI(service_config)
+    elif service_config["llm_service"].lower() == "sagemaker":
+        return AWS_SageMaker_Endpoint(service_config)
+    elif service_config["llm_service"].lower() == "vertexai":
+        return GoogleVertexAI(service_config)
+    elif service_config["llm_service"].lower() == "genai":
+        return GoogleGenAI(service_config)
+    elif service_config["llm_service"].lower() == "bedrock":
+        return AWSBedrock(service_config)
+    elif service_config["llm_service"].lower() == "groq":
+        return Groq(service_config)
+    elif service_config["llm_service"].lower() == "ollama":
+        return Ollama(service_config)
+    elif service_config["llm_service"].lower() == "huggingface":
+        return HuggingFaceEndpoint(service_config)
+    elif service_config["llm_service"].lower() == "watsonx":
+        return IBMWatsonX(service_config)
     else:
         raise Exception("LLM Completion Service Not Supported")
 
@@ -269,3 +334,190 @@ 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, completion_config, embedding_config, multimodal_config
+    
+    try:
+        # 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)
+            
+            # Preserve existing API keys if not provided in new config
+            existing_llm_config = server_config.get("llm_config", {})
+            
+            # Directly save the new LLM config without preserving old API keys
+            server_config["llm_config"] = new_llm_config
+            
+            with open(SERVER_CONFIG, "w") as f:
+                json.dump(server_config, f, indent=2)
+        
+        # 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
+        if "authentication_configuration" in new_llm_config:
+            if "completion_service" in new_llm_config:
+                new_llm_config["completion_service"]["authentication_configuration"] = new_llm_config["authentication_configuration"]
+            if "embedding_service" in new_llm_config:
+                new_llm_config["embedding_service"]["authentication_configuration"] = new_llm_config["authentication_configuration"]
+            if "multimodal_service" in new_llm_config:
+                new_llm_config["multimodal_service"]["authentication_configuration"] = new_llm_config["authentication_configuration"]
+        
+        new_completion_config = new_llm_config.get("completion_service")
+        new_embedding_config = new_llm_config.get("embedding_service")
+        new_multimodal_config = new_llm_config.get("multimodal_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")
+        
+        # Update llm_config in-place to preserve references in other modules (ui.py imports this)
+        llm_config.clear()
+        llm_config.update(new_llm_config)
+        
+        # Update service configs in-place to preserve references
+        completion_config.clear()
+        completion_config.update(new_completion_config)
+        
+        embedding_config.clear()
+        embedding_config.update(new_embedding_config)
+        
+        # multimodal_config can be reassigned (not imported elsewhere)
+        multimodal_config = new_multimodal_config
+        
+        # Re-initialize embedding service
+        if embedding_config["embedding_model_service"].lower() == "openai":
+            embedding_service = OpenAI_Embedding(embedding_config)
+        elif embedding_config["embedding_model_service"].lower() == "azure":
+            embedding_service = AzureOpenAI_Ada002(embedding_config)
+        elif embedding_config["embedding_model_service"].lower() == "vertexai":
+            embedding_service = VertexAI_PaLM_Embedding(embedding_config)
+        elif embedding_config["embedding_model_service"].lower() == "genai":
+            embedding_service = GenAI_Embedding(embedding_config)
+        elif embedding_config["embedding_model_service"].lower() == "bedrock":
+            embedding_service = AWS_Bedrock_Embedding(embedding_config)
+        elif embedding_config["embedding_model_service"].lower() == "ollama":
+            embedding_service = Ollama_Embedding(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:
+        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")
+        
+        db_config.clear()
+        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:
+        # Read from file
+        with open(SERVER_CONFIG, "r") as f:
+            server_config = json.load(f)
+        
+        # Validate
+        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
+        graphrag_config.clear()
+        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/llm_services/google_vertexai_service.py b/common/llm_services/google_vertexai_service.py
index 22679f5..2fec35b 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"]
@@ -38,3 +38,4 @@ def entity_relationship_extraction_prompt(self):
     @property
     def model(self):
         return self.llm
+
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/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/ecc/app/ecc_util.py b/ecc/app/ecc_util.py
index 75a3f87..aa6c5ed 100644
--- a/ecc/app/ecc_util.py
+++ b/ecc/app/ecc_util.py
@@ -1,5 +1,5 @@
 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.config import graphrag_config, embedding_service, llm_config, get_completion_config
 from common.llm_services import (
     AWS_SageMaker_Endpoint,
     AWSBedrock,
@@ -55,24 +55,27 @@ def get_chunker(chunker_type: str = ""):
     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"])
+def get_llm_service(graphname=None):
+    config = get_completion_config(graphname)
+    if config["llm_service"].lower() == "openai":
+        llm_provider = OpenAI(config)
+    elif config["llm_service"].lower() == "azure":
+        llm_provider = AzureOpenAI(config)
+    elif config["llm_service"].lower() == "sagemaker":
+        llm_provider = AWS_SageMaker_Endpoint(config)
+    elif config["llm_service"].lower() == "vertexai":
+        llm_provider = GoogleVertexAI(config)
+    elif config["llm_service"].lower() == "genai":
+        llm_provider = GoogleGenAI(config)
+    elif config["llm_service"].lower() == "bedrock":
+        llm_provider = AWSBedrock(config)
+    elif config["llm_service"].lower() == "groq":
+        llm_provider = Groq(config)
+    elif config["llm_service"].lower() == "ollama":
+        llm_provider = Ollama(config)
+    elif config["llm_service"].lower() == "huggingface":
+        llm_provider = HuggingFaceEndpoint(config)
+    else:
+        raise Exception("LLM Completion Service Not Supported")
 
     return llm_provider
diff --git a/ecc/app/graphrag/community_summarizer.py b/ecc/app/graphrag/community_summarizer.py
index 0bab35b..803ad17 100644
--- a/ecc/app/graphrag/community_summarizer.py
+++ b/ecc/app/graphrag/community_summarizer.py
@@ -12,26 +12,45 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import os
 import re
+import logging
 
 from langchain_core.prompts import PromptTemplate
 
 from common.llm_services import LLM_Model
 from common.py_schemas import CommunitySummary
+from common.config import completion_config
+
+logger = logging.getLogger(__name__)
+
+
+# Load prompt from file
+def load_community_prompt():
+    prompt_path = completion_config.get("prompt_path", "./common/prompts/openai_gpt4/")
+    if prompt_path.startswith("./"):
+        prompt_path = prompt_path[2:]
+    prompt_path = prompt_path.rstrip("/")
+
+    prompt_file = os.path.join(prompt_path, "community_summarization.txt")
+    if not os.path.exists(prompt_file):
+        error_msg = f"Community summarization prompt file not found: {prompt_file}. Please ensure the file exists in the configured prompt path."
+        logger.error(error_msg)
+        raise FileNotFoundError(error_msg)
+
+    try:
+        with open(prompt_file, "r", encoding="utf-8") as f:
+            content = f.read()
+            logger.info(f"Successfully loaded community summarization prompt from: {prompt_file}")
+            return content
+    except Exception as e:
+        error_msg = f"Failed to read community summarization prompt from {prompt_file}: {str(e)}"
+        logger.error(error_msg)
+        raise Exception(error_msg)
+
 
 # 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}
-""")
+SUMMARIZE_PROMPT = PromptTemplate.from_template(load_community_prompt())
 
 id_pat = re.compile(r"[_\d]*")
 
@@ -58,4 +77,4 @@ async def summarize(self, name: str, text: list[str]) -> CommunitySummary:
             )
         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/workers.py b/ecc/app/graphrag/workers.py
index 78f38be..4f8543a 100644
--- a/ecc/app/graphrag/workers.py
+++ b/ecc/app/graphrag/workers.py
@@ -440,7 +440,7 @@ async def process_community(
         if len(children) == 1:
             summary = children[0]
         else:
-            llm = ecc_util.get_llm_service()
+            llm = ecc_util.get_llm_service(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..b74989a 100644
--- a/ecc/app/main.py
+++ b/ecc/app/main.py
@@ -36,6 +36,7 @@
     embedding_service,
     get_llm_service,
     llm_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
@@ -213,6 +214,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 +278,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/graphrag-ui/src/components/Bot.tsx b/graphrag-ui/src/components/Bot.tsx
index 1f4e4e6..266fe2e 100644
--- a/graphrag-ui/src/components/Bot.tsx
+++ b/graphrag-ui/src/components/Bot.tsx
@@ -85,6 +85,7 @@ const Bot = ({ layout, getConversationId }: { layout?: string | undefined, getCo
   const handleSelect = (value) => {
     setSelectedGraph(value);
     localStorage.setItem("selectedGraph", value);
+    window.dispatchEvent(new Event("graphrag:selectedGraph"));
     navigate("/chat");
     //window.location.reload();
   };
diff --git a/graphrag-ui/src/components/ModeToggle.tsx b/graphrag-ui/src/components/ModeToggle.tsx
index a8109bc..8049162 100644
--- a/graphrag-ui/src/components/ModeToggle.tsx
+++ b/graphrag-ui/src/components/ModeToggle.tsx
@@ -1,4 +1,5 @@
 import { Moon, Sun, LogOut, Settings } from "lucide-react";
+import React from "react";
 import { useLocation, useNavigate } from "react-router-dom";
 
 import { Button } from "@/components/ui/button";
@@ -17,6 +18,67 @@ export function ModeToggle() {
   const location = useLocation();
   const isLoginRoute = location.pathname === "/";
   const [confirm, confirmDialog] = useConfirm();
+  const [userRoles, setUserRoles] = React.useState<string[]>([]);
+  const [graphRoles, setGraphRoles] = React.useState<Record<string, string[]>>({});
+  const [rolesLoaded, setRolesLoaded] = React.useState(false);
+  const [selectedGraph, setSelectedGraph] = React.useState(
+    localStorage.getItem("selectedGraph") || ""
+  );
+  const isGraphAdmin = (graphRoles[selectedGraph] || []).includes("admin");
+  const canAccessSetup =
+    userRoles.includes("superuser") ||
+    userRoles.includes("globaldesigner") ||
+    isGraphAdmin;
+
+  React.useEffect(() => {
+    const loadRoles = async () => {
+      try {
+        const creds = localStorage.getItem("creds");
+        if (!creds) {
+          setUserRoles([]);
+          setRolesLoaded(true);
+          return;
+        }
+        const response = await fetch("/ui/roles", {
+          headers: { Authorization: `Basic ${creds}` },
+        });
+        if (!response.ok) {
+          setUserRoles([]);
+          setRolesLoaded(true);
+          return;
+        }
+        const data = await response.json();
+        const roles = Array.isArray(data.roles) ? data.roles : [];
+        setUserRoles(roles.map((role: string) => role.toLowerCase()));
+        setGraphRoles(
+          data.graph_roles && typeof data.graph_roles === "object"
+            ? Object.fromEntries(
+                Object.entries(data.graph_roles).map(([graph, roles]) => [
+                  graph,
+                  Array.isArray(roles)
+                    ? roles.map((role: string) => role.toLowerCase())
+                    : [],
+                ])
+              )
+            : {}
+        );
+        setSelectedGraph(localStorage.getItem("selectedGraph") || "");
+      } finally {
+        setRolesLoaded(true);
+      }
+    };
+    loadRoles();
+  }, [location.pathname]);
+
+  React.useEffect(() => {
+    const handleGraphChange = () => {
+      setSelectedGraph(localStorage.getItem("selectedGraph") || "");
+    };
+    window.addEventListener("graphrag:selectedGraph", handleGraphChange);
+    return () => {
+      window.removeEventListener("graphrag:selectedGraph", handleGraphChange);
+    };
+  }, []);
 
   const handleLogout = async () => {
     // Show confirmation dialog
@@ -46,7 +108,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 +119,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/main.tsx b/graphrag-ui/src/main.tsx
index 69cfa82..5e298b5 100755
--- a/graphrag-ui/src/main.tsx
+++ b/graphrag-ui/src/main.tsx
@@ -1,10 +1,16 @@
 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";
 
@@ -42,7 +48,41 @@ const router = createBrowserRouter([
       },
       {
         path: "/setup",
-        element: <Setup />,
+        element: <SetupLayout />,
+        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 />,
+          },
+        ],
       },
     ],
   },
diff --git a/graphrag-ui/src/pages/setup/CustomizePrompts.tsx b/graphrag-ui/src/pages/setup/CustomizePrompts.tsx
new file mode 100644
index 0000000..ef13dfc
--- /dev/null
+++ b/graphrag-ui/src/pages/setup/CustomizePrompts.tsx
@@ -0,0 +1,298 @@
+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";
+
+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 [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 selectedGraph = localStorage.getItem("selectedGraph") || "";
+
+  const handleSavePrompt = async (promptId: string) => {
+    setIsSaving(true);
+    setSaveMessage("");
+    setSaveMessageType("");
+
+    try {
+      const creds = localStorage.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 }));
+  };
+
+  // Fetch prompts and configured LLM provider from server
+  useEffect(() => {
+    const fetchPrompts = async () => {
+      setIsLoading(true);
+      try {
+        const creds = localStorage.getItem("creds");
+        const query = selectedGraph ? `?graphname=${encodeURIComponent(selectedGraph)}` : "";
+        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);
+      }
+    };
+
+    fetchPrompts();
+  }, []);
+
+  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 three core prompts used by GraphRAG
+              </p>
+              <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                {selectedGraph
+                  ? `Editing prompt overrides for graph: ${selectedGraph}`
+                  : "Editing default prompts for all graphs"}
+              </p>
+            </div>
+          </div>
+        </div>
+
+        <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..d1f1c8c
--- /dev/null
+++ b/graphrag-ui/src/pages/setup/GraphDBConfig.tsx
@@ -0,0 +1,437 @@
+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 = () => {
+  const [hostname, setHostname] = useState("http://tigergraph");
+  const [restppPort, setRestppPort] = useState("9000");
+  const [gsPort, setGsPort] = useState("14240");
+  const [username, setUsername] = useState("");
+  const [password, setPassword] = useState("");
+  const [getToken, setGetToken] = useState(false);
+  const [defaultTimeout, setDefaultTimeout] = useState("300");
+  const [defaultMemThreshold, setDefaultMemThreshold] = useState("5000");
+  const [defaultThreadLimit, setDefaultThreadLimit] = useState("8");
+  
+  // Track original hostname to detect changes
+  const [originalHostname, setOriginalHostname] = 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 = localStorage.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) {
+        const loadedHostname = dbConfig.hostname || "http://tigergraph";
+        setHostname(loadedHostname);
+        setOriginalHostname(loadedHostname); // Track original hostname
+        setRestppPort(dbConfig.restppPort || "9000");
+        setGsPort(dbConfig.gsPort || "14240");
+        
+        setUsername(dbConfig.username || "");
+        setPassword(dbConfig.password || "");
+        
+        setGetToken(dbConfig.getToken || false);
+        setDefaultTimeout(String(dbConfig.default_timeout || 300));
+        setDefaultMemThreshold(String(dbConfig.default_mem_threshold || 5000));
+        setDefaultThreadLimit(String(dbConfig.default_thread_limit || 8));
+      }
+    } 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 = localStorage.getItem("creds");
+      const testConfig = {
+        hostname,
+        restppPort,
+        gsPort,
+        username,
+        password,
+        getToken,
+      };
+
+      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 = localStorage.getItem("creds");
+      const dbConfigData = {
+        hostname,
+        restppPort,
+        gsPort,
+        username,
+        password,
+        getToken,
+        default_timeout: parseInt(defaultTimeout),
+        default_mem_threshold: parseInt(defaultMemThreshold),
+        default_thread_limit: parseInt(defaultThreadLimit),
+      };
+
+      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 changed (different TigerGraph instance)
+        const hostnameChanged = originalHostname && hostname !== originalHostname;
+        
+        // Check if credentials changed from login credentials
+        let credentialsChanged = false;
+        const loginCreds = localStorage.getItem("creds");
+        if (loginCreds) {
+          try {
+            const decodedCreds = atob(loginCreds);
+            const [loginUsername, loginPassword] = decodedCreds.split(":");
+            credentialsChanged = loginUsername !== username || loginPassword !== password;
+          } catch (e) {
+            console.error("Error parsing login credentials:", e);
+          }
+        }
+        
+        // If hostname OR credentials changed, redirect to login
+        if (hostnameChanged || credentialsChanged) {
+          const reason = hostnameChanged 
+            ? "GraphDB hostname changed. Please relogin with the changed credentials to connect to the new instance."
+            : "GraphDB credentials changed. Please relogin with the changed credentials.";
+          
+          setTimeout(() => {
+            // Clear localStorage and redirect to login
+            localStorage.removeItem("creds");
+            alert(reason);
+            window.location.href = "/"; // Redirect to root (login page)
+          }, 2000); // Give user 2 seconds to see the success message
+        } else {
+          // Update original hostname after successful save (only if no redirect)
+          setOriginalHostname(hostname);
+        }
+      } 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">
+                GraphDB 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="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="tigergraph"
+                      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=""
+                      value={password}
+                      onChange={(e) => {
+                        setPassword(e.target.value);
+                        setConnectionTested(false);
+                        setMessage("");
+                        setMessageType("");
+                      }}
+                    />
+                  </div>
+                </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>
+
+                <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>
+
+                {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 gap-4">
+                  <Button
+                    onClick={handleTestConnection}
+                    disabled={isTesting || !username || !password}
+                    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>
+                </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..068509f
--- /dev/null
+++ b/graphrag-ui/src/pages/setup/GraphRAGConfig.tsx
@@ -0,0 +1,408 @@
+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";
+
+const GraphRAGConfig = () => {
+  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");
+  
+  // 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" | "">("");
+
+  useEffect(() => {
+    fetchConfig();
+  }, []);
+
+
+  const fetchConfig = async () => {
+    setIsLoading(true);
+    try {
+      const creds = localStorage.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 graphragConfig = data.graphrag_config;
+
+      if (graphragConfig) {
+        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");
+        
+        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");
+      }
+    } 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 = localStorage.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 = {
+        reuse_embedding: reuseEmbedding,
+        ecc: eccUrl,
+        chat_history_api: chatHistoryUrl,
+        chunker: defaultChunker,
+        chunker_config: chunkerConfig
+      };
+
+      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>
+
+        {/* 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>
+                <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>
+
+          {/* 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>
+          )}
+
+          <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..0c9113a
--- /dev/null
+++ b/graphrag-ui/src/pages/setup/IngestGraph.tsx
@@ -0,0 +1,1557 @@
+import React, { useState, useEffect } 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";
+
+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 [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 = localStorage.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...");
+
+    try {
+      const creds = localStorage.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);
+        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...");
+
+    try {
+      const creds = localStorage.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);
+      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 = localStorage.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 = localStorage.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 = localStorage.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 = localStorage.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 = localStorage.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 = localStorage.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 = localStorage.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 = localStorage.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 = localStorage.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 = localStorage.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("/")[-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);
+    }
+  };
+
+  // Load available graphs from localStorage on mount
+  useEffect(() => {
+    const store = JSON.parse(localStorage.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
+                    type="file"
+                    multiple
+                    onChange={(e) => setSelectedFiles(e.target.files)}
+                    disabled={isUploading}
+                    className="dark:border-[#3D3D3D] dark:bg-shadeA"
+                  />
+                  <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 || !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"
+                      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"
+                            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..cea8389
--- /dev/null
+++ b/graphrag-ui/src/pages/setup/KGAdmin.tsx
@@ -0,0 +1,664 @@
+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 {
+  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("");
+    }
+  };
+
+  // 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);
+
+  // Load available graphs
+  useEffect(() => {
+    const store = JSON.parse(localStorage.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;
+    }
+
+    setIsInitializing(true);
+    setStatusMessage("Creating graph and initializing GraphRAG schema...");
+    setStatusType("");
+
+    try {
+      const creds = localStorage.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) {
+        throw new Error(
+          createData.detail ||
+            createData.message ||
+            `Failed to create graph: ${createResponse.statusText}`
+        );
+      }
+
+      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(localStorage.getItem("site") || "{}");
+          store.graphs = updated;
+          localStorage.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 = localStorage.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) {
+          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}".`);
+        } else if (statusData.status === "failed") {
+          setRefreshMessage(`❌ Previous rebuild failed: ${statusData.error || "Unknown error"}`);
+        } else if (statusData.status === "error") {
+          setRefreshMessage(`❌ Failed to check rebuild status: ${statusData.error || "Unknown error"}`);
+        } else if (statusData.status === "unknown") {
+          setRefreshMessage(`⚠️ ECC service returned unknown status. It may be unavailable.`);
+        } 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 = localStorage.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;
+    } catch (error: any) {
+      console.error("Error refreshing graph:", error);
+      setRefreshMessage(`❌ Error: ${error.message}`);
+    } finally {
+      setIsRefreshing(false);
+    }
+  };
+
+  // Check status on interval
+  useEffect(() => {
+    if (refreshDialogOpen && refreshGraphName) {
+      checkRebuildStatus(refreshGraphName, true);
+
+      const intervalId = setInterval(() => {
+        checkRebuildStatus(refreshGraphName, false);
+      }, 5000);
+
+      return () => clearInterval(intervalId);
+    }
+  }, [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 Administration
+          </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...
+                  </>
+                ) : isCheckingStatus ? (
+                  <>
+                    <Loader2 className="h-4 w-4 mr-2 animate-spin" />
+                    Checking Status...
+                  </>
+                ) : isRebuildRunning ? (
+                  <>
+                    <Loader2 className="h-4 w-4 mr-2 animate-spin" />
+                    Rebuild In Progress...
+                  </>
+                ) : (
+                  <>
+                    <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..f79704b
--- /dev/null
+++ b/graphrag-ui/src/pages/setup/LLMConfig.tsx
@@ -0,0 +1,1344 @@
+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";
+
+// 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 = localStorage.getItem("selectedGraph") || "";
+  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 [singleChatbotModel, setSingleChatbotModel] = useState("");
+  const [singleUseDifferentChatbotModel, setSingleUseDifferentChatbotModel] = useState(false);
+  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 [completionChatbotModel, setCompletionChatbotModel] = useState("");
+  const [completionUseDifferentChatbotModel, setCompletionUseDifferentChatbotModel] = useState(false);
+  
+  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";
+
+
+  // Fetch current config on mount
+  useEffect(() => {
+    fetchConfig();
+  }, []);
+
+  const fetchConfig = async () => {
+    setIsLoading(true);
+    try {
+      const creds = localStorage.getItem("creds");
+      const graphParam = selectedGraph ? `?graphname=${encodeURIComponent(selectedGraph)}` : "";
+      const response = await fetch(`/ui/config${graphParam}`, {
+        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");
+      const currentDefaultModel = llmConfig.completion_service?.llm_model || "";
+      const currentChatbotModel = llmConfig.completion_service?.chatbot_llm || "";
+      setSingleDefaultModel(currentDefaultModel);
+      setSingleChatbotModel(currentChatbotModel);
+      setSingleUseDifferentChatbotModel(
+        currentDefaultModel !== "" &&
+          currentChatbotModel !== "" &&
+          currentDefaultModel !== currentChatbotModel
+      );
+
+      // 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 allSameProvider = 
+        completionProv === embeddingProv && 
+        (!multimodalProv || completionProv === multimodalProv);
+      
+      setUseMultipleProviders(!allSameProvider);
+
+      if (!allSameProvider) {
+        // Multi-provider mode - Load from backend
+        const defaultModel = llmConfig.completion_service?.llm_model || "";
+        const chatbotModel = llmConfig.completion_service?.chatbot_llm || "";
+        
+        setCompletionProvider(completionProv || "openai");
+        setCompletionDefaultModel(defaultModel);
+        setCompletionChatbotModel(chatbotModel);
+        setCompletionUseDifferentChatbotModel(defaultModel !== "" && chatbotModel !== "" && defaultModel !== chatbotModel);
+        
+        // Load provider-specific config fields
+        const completionCfg: Record<string, string> = {};
+        if (llmConfig.completion_service?.base_url) completionCfg.base_url = llmConfig.completion_service.base_url;
+        if (llmConfig.completion_service?.azure_deployment) completionCfg.azure_deployment = llmConfig.completion_service.azure_deployment;
+        if (llmConfig.completion_service?.region_name) completionCfg.region_name = llmConfig.completion_service.region_name;
+        if (llmConfig.completion_service?.project) completionCfg.project = llmConfig.completion_service.project;
+        if (llmConfig.completion_service?.location) completionCfg.location = llmConfig.completion_service.location;
+        if (llmConfig.completion_service?.endpoint_name) completionCfg.endpoint_name = llmConfig.completion_service.endpoint_name;
+        if (llmConfig.completion_service?.endpoint_url) completionCfg.endpoint_url = llmConfig.completion_service.endpoint_url;
+        setCompletionConfig(completionCfg);
+
+        setEmbeddingProvider(embeddingProv || "openai");
+        setEmbeddingModel(llmConfig.embedding_service?.model_name || "");
+        
+        const embeddingCfg: Record<string, string> = {};
+        if (llmConfig.embedding_service?.base_url) embeddingCfg.base_url = llmConfig.embedding_service.base_url;
+        if (llmConfig.embedding_service?.azure_deployment) embeddingCfg.azure_deployment = llmConfig.embedding_service.azure_deployment;
+        if (llmConfig.embedding_service?.region_name) embeddingCfg.region_name = llmConfig.embedding_service.region_name;
+        setEmbeddingConfig(embeddingCfg);
+
+        setMultimodalProvider(multimodalProv || "openai");
+        setMultimodalModelName(llmConfig.multimodal_service?.llm_model || "");
+        
+        const multimodalCfg: Record<string, string> = {};
+        if (llmConfig.multimodal_service?.azure_deployment) multimodalCfg.azure_deployment = llmConfig.multimodal_service.azure_deployment;
+        setMultimodalConfig(multimodalCfg);
+      } else {
+        // Single provider mode - Load from backend
+        const defaultModel = llmConfig.completion_service?.llm_model || "";
+        const chatbotModel = llmConfig.completion_service?.chatbot_llm || "";
+        
+        setSingleProvider(completionProv || "openai");
+        setSingleDefaultModel(defaultModel);
+        setSingleChatbotModel(chatbotModel);
+        setSingleUseDifferentChatbotModel(defaultModel !== "" && chatbotModel !== "" && defaultModel !== chatbotModel);
+        setSingleEmbeddingModel(llmConfig.embedding_service?.model_name || "");
+        setMultimodalModel(llmConfig.multimodal_service?.llm_model || "");
+        
+        // Load provider-specific config fields
+        const singleCfg: Record<string, string> = {};
+        if (llmConfig.completion_service?.base_url) singleCfg.base_url = llmConfig.completion_service.base_url;
+        if (llmConfig.completion_service?.azure_deployment) singleCfg.azure_deployment = llmConfig.completion_service.azure_deployment;
+        if (llmConfig.completion_service?.region_name) singleCfg.region_name = llmConfig.completion_service.region_name;
+        if (llmConfig.completion_service?.project) singleCfg.project = llmConfig.completion_service.project;
+        if (llmConfig.completion_service?.location) singleCfg.location = llmConfig.completion_service.location;
+        if (llmConfig.completion_service?.endpoint_name) singleCfg.endpoint_name = llmConfig.completion_service.endpoint_name;
+        if (llmConfig.completion_service?.endpoint_url) singleCfg.endpoint_url = llmConfig.completion_service.endpoint_url;
+        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("");
+      setSingleChatbotModel("");
+      setSingleEmbeddingModel("");
+      setMultimodalModel("");
+    } else if (target === 'completion') {
+      setCompletionProvider(newProvider);
+      setCompletionConfig({});
+      // Clear model names when switching provider
+      setCompletionDefaultModel("");
+      setCompletionChatbotModel("");
+    } 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 = localStorage.getItem("creds");
+      let llmConfigData: any;
+
+      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)
+        };
+        
+        // Only add chatbot_llm if user wants a different chatbot model
+        if (completionUseDifferentChatbotModel && completionChatbotModel && completionChatbotModel !== completionDefaultModel) {
+          completionServiceConfig.chatbot_llm = completionChatbotModel;
+        }
+        
+        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)
+          },
+        };
+      } else {
+        const completionServiceConfig: any = {
+          llm_service: singleProvider,
+          llm_model: singleDefaultModel,
+          model_kwargs: { temperature: 0 },
+          prompt_path: `./common/prompts/${getPromptPath(singleProvider)}/`,
+          ...buildServiceConfig(singleProvider, singleConfig)
+        };
+        
+        // Only add chatbot_llm if user wants a different chatbot model
+        if (singleUseDifferentChatbotModel && singleChatbotModel && singleChatbotModel !== singleDefaultModel) {
+          completionServiceConfig.chatbot_llm = singleChatbotModel;
+        }
+        
+        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)
+          },
+        };
+      }
+
+      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 and reloaded successfully!");
+      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 = localStorage.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)
+          },
+        };
+        
+        if (completionUseDifferentChatbotModel && completionChatbotModel !== completionDefaultModel) {
+          llmConfigData.chatbot_service = {
+            llm_service: completionProvider,
+            llm_model: completionChatbotModel,
+            authentication_configuration: buildAuthConfig(completionProvider, completionConfig),
+            ...buildServiceConfig(completionProvider, completionConfig)
+          };
+        }
+        
+        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)
+          },
+        };
+        
+        if (singleUseDifferentChatbotModel && singleChatbotModel !== singleDefaultModel) {
+          llmConfigData.chatbot_service = {
+            llm_service: singleProvider,
+            llm_model: singleChatbotModel,
+          };
+        }
+      }
+
+      if (isChatbotOnlyMode) {
+        llmConfigData = {
+          graphname: selectedGraph || undefined,
+          completion_service: {
+            chatbot_llm: useDifferentChatbotModel ? chatbotModel : "",
+          },
+        };
+      }
+
+      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>
+        ))}
+      </>
+    );
+  };
+
+  const chatbotDefaultModel = useMultipleProviders
+    ? completionDefaultModel
+    : singleDefaultModel;
+  const chatbotModel = useMultipleProviders
+    ? completionChatbotModel
+    : singleChatbotModel;
+  const useDifferentChatbotModel = useMultipleProviders
+    ? completionUseDifferentChatbotModel
+    : singleUseDifferentChatbotModel;
+
+  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">
+                  LLM Configuration
+                </h1>
+                <p className="text-sm text-gray-600 dark:text-[#D9D9D9]">
+                  You can only update Chatbot model for selected graph.
+                </p>
+              </div>
+            </div>
+          </div>
+
+          <div className="space-y-6">
+            <div className="bg-white dark:bg-shadeA border border-gray-300 dark:border-[#3D3D3D] rounded-lg p-6">
+              <div className="space-y-4">
+                <div>
+                  <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                    Default LLM Model (Read-only)
+                  </label>
+                  <Input
+                    type="text"
+                    className="dark:border-[#3D3D3D] dark:bg-background"
+                    value={chatbotDefaultModel}
+                    readOnly
+                    disabled
+                  />
+                  <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                    This model is configured by global designer/superuser.
+                  </p>
+                </div>
+
+                <div className="flex items-center space-x-3 mt-3">
+                  <input
+                    type="checkbox"
+                    id="chatbotOnlyUseDifferentChatbot"
+                    checked={useDifferentChatbotModel}
+                    onChange={(e) => {
+                      if (useMultipleProviders) {
+                        setCompletionUseDifferentChatbotModel(e.target.checked);
+                      } else {
+                        setSingleUseDifferentChatbotModel(e.target.checked);
+                      }
+                      clearTestResults();
+                    }}
+                    className="h-4 w-4 rounded border-gray-300 dark:border-[#3D3D3D]"
+                  />
+                  <label htmlFor="chatbotOnlyUseDifferentChatbot" className="text-sm font-medium text-black dark:text-white">
+                    Use different model for Chatbot
+                  </label>
+                </div>
+
+                {useDifferentChatbotModel && (
+                  <div>
+                    <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                      Chatbot LLM Model
+                    </label>
+                    <Input
+                      type="text"
+                      className="dark:border-[#3D3D3D] dark:bg-background"
+                      placeholder="e.g. gpt-4.1-mini"
+                      value={chatbotModel}
+                      onChange={(e) => {
+                        if (useMultipleProviders) {
+                          setCompletionChatbotModel(e.target.value);
+                        } else {
+                          setSingleChatbotModel(e.target.value);
+                        }
+                        clearTestResults();
+                      }}
+                    />
+                    <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                      Leave unchecked to use the default model.
+                    </p>
+                    <p className="text-xs text-amber-600 dark:text-amber-400 mt-1">
+                      Make sure the chatbot model name is exact and supported by your configured provider.
+                    </p>
+                  </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>
+            )}
+
+            <div className="flex gap-3">
+              <Button
+                onClick={handleSave}
+                disabled={isSaving || isTesting}
+                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">
+          {/* 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 Models
+                      </label>
+                      <p className="text-xs text-gray-500 dark:text-gray-400 mb-3">
+                        Configure the LLM models used by the ECC service for document processing (entity extraction and community summarization) and by the chatbot for user query responses
+                      </p>
+                      
+                      <div className="space-y-3 pl-4 border-l-2 border-gray-200 dark:border-[#3D3D3D]">
+                        <div>
+                          <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                            Default LLM 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 className="flex items-center space-x-3 mt-3">
+                          <input
+                            type="checkbox"
+                            id="singleUseDifferentChatbot"
+                            checked={singleUseDifferentChatbotModel}
+                            onChange={(e) => {
+                              setSingleUseDifferentChatbotModel(e.target.checked);
+                              clearTestResults();
+                            }}
+                            className="h-4 w-4 rounded border-gray-300 dark:border-[#3D3D3D]"
+                          />
+                          <label htmlFor="singleUseDifferentChatbot" className="text-sm font-medium text-black dark:text-white">
+                            Use different model for Chatbot
+                          </label>
+                        </div>
+
+                        {singleUseDifferentChatbotModel && (
+                          <div>
+                            <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                              Chatbot LLM Model
+                            </label>
+                            <Input
+                              type="text"
+                              className="dark:border-[#3D3D3D] dark:bg-background"
+                              placeholder={getModelPlaceholder(singleProvider, 'llm')}
+                              value={singleChatbotModel}
+                              onChange={(e) => {
+                                setSingleChatbotModel(e.target.value);
+                                clearTestResults();
+                              }}
+                            />
+                            <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                              Used by chatbot for answering user questions
+                            </p>
+                          </div>
+                        )}
+                      </div>
+                    </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 models used by the ECC service for document processing (entity extraction and community summarization) and by the chatbot for user query responses
+                </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 Models
+                    </label>
+                    
+                    <div className="space-y-3 pl-4 border-l-2 border-gray-200 dark:border-[#3D3D3D]">
+                      <div>
+                        <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                          Default LLM 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 className="flex items-center space-x-3 mt-3">
+                        <input
+                          type="checkbox"
+                          id="completionUseDifferentChatbot"
+                          checked={completionUseDifferentChatbotModel}
+                          onChange={(e) => {
+                            setCompletionUseDifferentChatbotModel(e.target.checked);
+                            clearTestResults();
+                          }}
+                          className="h-4 w-4 rounded border-gray-300 dark:border-[#3D3D3D]"
+                        />
+                        <label htmlFor="completionUseDifferentChatbot" className="text-sm font-medium text-black dark:text-white">
+                          Use different model for Chatbot
+                        </label>
+                      </div>
+
+                      {completionUseDifferentChatbotModel && (
+                        <div>
+                          <label className="block text-sm font-medium mb-2 text-black dark:text-white">
+                            Chatbot LLM Model
+                          </label>
+                          <Input
+                            type="text"
+                            className="dark:border-[#3D3D3D] dark:bg-background"
+                            placeholder={getModelPlaceholder(completionProvider, 'llm')}
+                            value={completionChatbotModel}
+                            onChange={(e) => {
+                              setCompletionChatbotModel(e.target.value);
+                              clearTestResults();
+                            }}
+                          />
+                          <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                            Used by chatbot for answering user questions
+                          </p>
+                        </div>
+                      )}
+                    </div>
+                  </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..6f35781
--- /dev/null
+++ b/graphrag-ui/src/pages/setup/SetupLayout.tsx
@@ -0,0 +1,260 @@
+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";
+
+const SetupLayout = () => {
+  const navigate = useNavigate();
+  const location = useLocation();
+  const [userRoles, setUserRoles] = React.useState<string[]>([]);
+  const [graphRoles, setGraphRoles] = React.useState<Record<string, string[]>>({});
+  const [rolesLoaded, setRolesLoaded] = React.useState(false);
+  const [hasCreds, setHasCreds] = React.useState(false);
+  const isSuperuser = userRoles.includes("superuser");
+  const isGlobalDesigner = userRoles.includes("globaldesigner");
+  const selectedGraph = localStorage.getItem("selectedGraph") || "";
+  const selectedGraphRoles = graphRoles[selectedGraph] || [];
+  const isGraphAdmin = selectedGraphRoles.includes("admin");
+  const canAccessPrompts = isSuperuser || isGlobalDesigner || isGraphAdmin;
+  const canAccessSetup = isSuperuser || isGlobalDesigner || isGraphAdmin;
+  const canAccessLlmConfig = isSuperuser || isGlobalDesigner || isGraphAdmin;
+
+  const menuItems = [
+    {
+      title: "Knowledge Graph Administration",
+      icon: Database,
+      path: "/setup/kg-admin",
+      subItems: [],
+    },
+    {
+      title: "Server Configuration",
+      icon: Settings,
+      path: "/setup/server-config",
+      subItems: [
+        ...(canAccessLlmConfig ? [{ title: "LLM Config", path: "/setup/server-config/llm" }] : []),
+        ...(isSuperuser ? [{ title: "GraphDB Config", path: "/setup/server-config/graphdb" }] : []),
+        ...(isSuperuser || isGlobalDesigner ? [{ title: "GraphRAG Config", path: "/setup/server-config/graphrag" }] : []),
+      ],
+    },
+    {
+      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 loadRoles = async () => {
+      try {
+        const creds = localStorage.getItem("creds");
+        if (!creds) {
+          setUserRoles([]);
+          setGraphRoles({});
+          setHasCreds(false);
+          setRolesLoaded(true);
+          return;
+        }
+        const response = await fetch("/ui/roles", {
+          headers: { Authorization: `Basic ${creds}` },
+        });
+        if (!response.ok) {
+          setUserRoles([]);
+          setGraphRoles({});
+          setHasCreds(false);
+          setRolesLoaded(true);
+          return;
+        }
+        const data = await response.json();
+        const roles = Array.isArray(data.roles) ? data.roles : [];
+        setUserRoles(roles.map((role: string) => role.toLowerCase()));
+        setGraphRoles(
+          data.graph_roles && typeof data.graph_roles === "object"
+            ? Object.fromEntries(
+                Object.entries(data.graph_roles).map(([graph, roles]) => [
+                  graph,
+                  Array.isArray(roles)
+                    ? roles.map((role: string) => role.toLowerCase())
+                    : [],
+                ])
+              )
+            : {}
+        );
+        setHasCreds(true);
+      } finally {
+        setRolesLoaded(true);
+      }
+    };
+    loadRoles();
+
+    // Auto-expand section based on current path
+    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..e4264ed 100644
--- a/graphrag/app/agent/agent.py
+++ b/graphrag/app/agent/agent.py
@@ -8,7 +8,7 @@
 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
 from common.embeddings.base_embedding_store import EmbeddingStore
 from common.embeddings.embedding_services import EmbeddingModel
 from common.llm_services import (
@@ -166,39 +166,38 @@ 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"]
+    completion_service_config = get_completion_config(graphname)
 
-    if llm_config["completion_service"]["llm_service"].lower() == "openai":
+    if completion_service_config["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_provider = OpenAI(completion_service_config)
+    elif completion_service_config["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_provider = AzureOpenAI(completion_service_config)
+    elif completion_service_config["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_provider = AWS_SageMaker_Endpoint(completion_service_config)
+    elif completion_service_config["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_provider = GoogleVertexAI(completion_service_config)
+    elif completion_service_config["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_provider = GoogleGenAI(completion_service_config)
+    elif completion_service_config["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_provider = AWSBedrock(completion_service_config)
+    elif completion_service_config["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_provider = Groq(completion_service_config)
+    elif completion_service_config["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_provider = Ollama(completion_service_config)
+    elif completion_service_config["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_provider = HuggingFaceEndpoint(completion_service_config)
+    elif completion_service_config["llm_service"].lower() == "watsonx":
         llm_service_name = "watsonx"
-        llm_provider = IBMWatsonX(llm_config["completion_service"])
+        llm_provider = IBMWatsonX(completion_service_config)
     else:
         LogWriter.error(
             f"/{graphname}/query_with_history request_id={req_id_cv.get()} agent creation failed due to invalid llm_service"
diff --git a/graphrag/app/routers/ui.py b/graphrag/app/routers/ui.py
index 0fc1473..dd3248f 100644
--- a/graphrag/app/routers/ui.py
+++ b/graphrag/app/routers/ui.py
@@ -14,10 +14,12 @@
 
 import asyncio
 import base64
+import copy
 import json
 import logging
 import os
 import re
+import shutil
 import time
 import traceback
 import uuid
@@ -46,7 +48,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, completion_config, SERVER_CONFIG, get_completion_config, get_server_config_path
 from common.db.connections import get_db_connection_pwd_manual
 from common.logs.log import req_id_cv
 from common.logs.logwriter import LogWriter
@@ -70,6 +72,154 @@
 router = APIRouter(tags=["UI"])
 security = HTTPBasic()
 GRAPH_NAME_RE = re.compile(r"- Graph (.*)\(")
+llm_config_lock = asyncio.Lock()
+
+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_roles(username: str, password: str) -> list[str]:
+    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")
+    return _parse_user_roles(user_info, username)
+
+
+def _get_user_role_details(username: str, password: str) -> tuple[list[str], dict[str, list[str]]]:
+    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")
+    return _parse_user_roles_detail(user_info, username)
+
+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 _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)
+    """
+    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:
+    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://localhost: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]:
@@ -104,6 +254,14 @@ def ws_basic_auth(auth_info: str, graphname=None):
     conn = get_db_connection_pwd_manual(graphname, username, password)
     return auth(username, password, conn)
 
+def get_chat_model_name() -> str:
+    completion_service = llm_config.get("completion_service", {})
+    if "chatbot_llm" in completion_service:
+        return completion_service["chatbot_llm"]
+    if "llm_model" in completion_service:
+        return completion_service["llm_model"]
+    return llm_config.get("model_name", "unknown")
+
 
 def ui_basic_auth(
     creds: Annotated[HTTPBasicCredentials, Depends(security)],
@@ -365,7 +523,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 +536,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 {
@@ -573,6 +740,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,
@@ -834,7 +1011,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_model_name(),
             content=data,
             role=Role.USER,
         )
@@ -854,7 +1031,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_model_name(),
             content=resp.natural_language_response,
             role=Role.SYSTEM,
             response_time=elapsed,
@@ -918,6 +1095,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 +1127,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_model_name(),
                 content=data,
                 role=Role.USER,
             )
@@ -966,7 +1147,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_model_name(),
                 content=resp.natural_language_response,
                 role=Role.SYSTEM,
                 response_time=elapsed,
@@ -985,8 +1166,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()
 
 
@@ -1570,3 +1759,710 @@ 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.get("graphname")
+        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
+
+            if llm_access_mode == "chatbot_only":
+                incoming_completion = llm_config_data.get("completion_service", {})
+                chatbot_model = incoming_completion.get("chatbot_llm", "") if isinstance(incoming_completion, dict) else ""
+
+                # Write chatbot_llm to graph-specific config file, not the default
+                graph_config_dir = f"configs/{graphname}"
+                os.makedirs(graph_config_dir, exist_ok=True)
+                graph_config_path = os.path.join(graph_config_dir, "server_config.json")
+                config_source = graph_config_path if os.path.exists(graph_config_path) else SERVER_CONFIG
+                with open(config_source, "r") as f:
+                    graph_server_config = json.load(f)
+                if chatbot_model:
+                    graph_server_config["llm_config"]["completion_service"]["chatbot_llm"] = chatbot_model
+                else:
+                    graph_server_config["llm_config"]["completion_service"].pop("chatbot_llm", None)
+                with open(graph_config_path, "w") as f:
+                    json.dump(graph_server_config, f, indent=2)
+                result = {"status": "success"}
+            else:
+                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:
+        _require_roles(credentials, {"superuser", "globaldesigner"})
+        from common import config as cfg
+        from common.llm_services import (
+            OpenAI, AzureOpenAI, GoogleGenAI, GoogleVertexAI,
+            AWSBedrock, AWS_SageMaker_Endpoint, Groq, Ollama,
+            HuggingFaceEndpoint, IBMWatsonX
+        )
+        from common.embeddings.embedding_services import (
+            OpenAI_Embedding, AzureOpenAI_Ada002, GenAI_Embedding,
+            VertexAI_PaLM_Embedding, AWS_Bedrock_Embedding, Ollama_Embedding
+        )
+        
+        test_results = {
+            "completion": {"status": "not_tested", "message": ""},
+            "chatbot": {"status": "not_tested", "message": ""},
+            "embedding": {"status": "not_tested", "message": ""},
+            "multimodal": {"status": "not_tested", "message": ""}
+        }
+        
+        # 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/"
+                
+                # Create LLM service instance based on provider
+                llm_service = None
+                if provider == "openai":
+                    llm_service = OpenAI(test_completion_config)
+                elif provider == "azure":
+                    llm_service = AzureOpenAI(test_completion_config)
+                elif provider == "genai":
+                    llm_service = GoogleGenAI(test_completion_config)
+                elif provider == "vertexai":
+                    llm_service = GoogleVertexAI(test_completion_config)
+                elif provider == "bedrock":
+                    llm_service = AWSBedrock(test_completion_config)
+                elif provider == "groq":
+                    llm_service = Groq(test_completion_config)
+                elif provider == "ollama":
+                    llm_service = Ollama(test_completion_config)
+                
+                if llm_service:
+                    # Test with a simple prompt
+                    response = llm_service.model.invoke("Say 'Connection successful' in 2 words")
+                    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/"
+                
+                # Create LLM service instance based on provider
+                llm_service = None
+                if provider == "openai":
+                    llm_service = OpenAI(test_chatbot_config)
+                elif provider == "azure":
+                    llm_service = AzureOpenAI(test_chatbot_config)
+                elif provider == "genai":
+                    llm_service = GoogleGenAI(test_chatbot_config)
+                elif provider == "vertexai":
+                    llm_service = GoogleVertexAI(test_chatbot_config)
+                elif provider == "bedrock":
+                    llm_service = AWSBedrock(test_chatbot_config)
+                elif provider == "groq":
+                    llm_service = Groq(test_chatbot_config)
+                elif provider == "ollama":
+                    llm_service = Ollama(test_chatbot_config)
+                
+                if llm_service:
+                    # Test with a simple prompt
+                    response = llm_service.model.invoke("Say 'Connection successful' in 2 words")
+                    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]
+                
+                # Create embedding service instance based on provider
+                embedding_service_test = None
+                if provider == "openai":
+                    embedding_service_test = OpenAI_Embedding(test_embedding_config)
+                elif provider == "azure":
+                    embedding_service_test = AzureOpenAI_Ada002(test_embedding_config)
+                elif provider == "genai":
+                    embedding_service_test = GenAI_Embedding(test_embedding_config)
+                elif provider == "vertexai":
+                    embedding_service_test = VertexAI_PaLM_Embedding(test_embedding_config)
+                elif provider == "bedrock":
+                    embedding_service_test = AWS_Bedrock_Embedding(test_embedding_config)
+                elif provider == "ollama":
+                    embedding_service_test = Ollama_Embedding(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/"
+                
+                # Create multimodal service instance based on provider
+                multimodal_service = None
+                if provider == "openai":
+                    multimodal_service = OpenAI(test_multimodal_config)
+                elif provider == "azure":
+                    multimodal_service = AzureOpenAI(test_multimodal_config)
+                elif provider == "genai":
+                    multimodal_service = GoogleGenAI(test_multimodal_config)
+                elif provider == "vertexai":
+                    multimodal_service = GoogleVertexAI(test_multimodal_config)
+                
+                if multimodal_service:
+                    # Test with a simple prompt
+                    response = multimodal_service.model.invoke("Say 'Connection successful' in 2 words")
+                    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 Exception as e:
+        logger.error(f"LLM connection test failed: {str(e)}")
+        return {
+            "status": "error",
+            "message": f"Test failed: {str(e)}",
+            "results": test_results
+        }
+
+
+@router.get(f"{route_prefix}/config")
+async def get_config(
+    credentials: Annotated[HTTPBasicCredentials, Depends(security)],
+    graphname: str | None = None,
+):
+    """
+    Get current server configuration to display in UI.
+    Returns config WITHOUT any API keys or secrets.
+    """
+    try:
+        llm_access_mode = _resolve_llm_config_access(credentials, graphname)
+        
+        # Deep copy to avoid modifying original
+        safe_llm_config = copy.deepcopy(llm_config)
+        
+        # Remove entire authentication_configuration sections (don't send API keys at all)
+        if "authentication_configuration" in safe_llm_config:
+            del safe_llm_config["authentication_configuration"]
+        
+        for service_key in ["completion_service", "embedding_service", "multimodal_service"]:
+            if service_key in safe_llm_config and "authentication_configuration" in safe_llm_config[service_key]:
+                del safe_llm_config[service_key]["authentication_configuration"]
+        
+        if llm_access_mode == "chatbot_only":
+            return {
+                "llm_config": safe_llm_config,
+                "llm_config_access": "chatbot_only",
+            }
+
+        return {
+            "llm_config": safe_llm_config,
+            "db_config": db_config,
+            "graphrag_config": graphrag_config,
+            "llm_config_access": "full",
+        }
+    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"})
+        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 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
+        
+        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 to server_config.json.
+    """
+    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
+        
+        # Read current full config
+        with open(SERVER_CONFIG, "r") as f:
+            server_config = json.load(f)
+        
+        # Update graphrag_config section
+        server_config["graphrag_config"] = graphrag_config_data
+        
+        # Write back to file atomically (write to temp, then rename)
+        temp_file = f"{SERVER_CONFIG}.tmp"
+        with open(temp_file, "w") as f:
+            json.dump(server_config, f, indent=2)
+        
+        # Rename temp file to actual config file (atomic operation)
+        os.replace(temp_file, SERVER_CONFIG)
+        
+        # Update in-memory graphrag_config to reflect changes immediately
+        graphrag_config.clear()
+        graphrag_config.update(graphrag_config_data)
+        
+        logger.info("GraphRAG configuration saved successfully")
+        
+        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_completion_config(graphname)
+        prompt_path = active_config.get("prompt_path", "./common/prompts/openai_gpt4/")
+        if prompt_path.startswith("./"):
+            prompt_path = prompt_path[2:]
+        prompt_path = prompt_path.rstrip("/")
+
+        prompts = {}
+
+        chatbot_file = os.path.join(prompt_path, "chatbot_response.txt")
+        if os.path.exists(chatbot_file):
+            with open(chatbot_file, "r", encoding="utf-8") as f:
+                prompts["chatbot_response"] = split_prompt_template(f.read(), "chatbot_response")
+        else:
+            prompts["chatbot_response"] = {"editable_content": "", "template_variables": ""}
+
+        entity_file = os.path.join(prompt_path, "entity_relationship_extraction.txt")
+        if os.path.exists(entity_file):
+            with open(entity_file, "r", encoding="utf-8") as f:
+                prompts["entity_relationship"] = split_prompt_template(f.read(), "entity_relationship")
+        else:
+            prompts["entity_relationship"] = {"editable_content": "", "template_variables": ""}
+
+        community_file = os.path.join(prompt_path, "community_summarization.txt")
+        if os.path.exists(community_file):
+            with open(community_file, "r", encoding="utf-8") as f:
+                prompts["community_summarization"] = split_prompt_template(f.read(), "community_summarization")
+        else:
+            prompts["community_summarization"] = {"editable_content": "", "template_variables": ""}
+
+        query_gen_file = os.path.join(prompt_path, "map_question_to_schema.txt")
+        if not os.path.exists(query_gen_file):
+            query_gen_file = os.path.join(prompt_path, "query_generation.txt")
+        if os.path.exists(query_gen_file):
+            with open(query_gen_file, "r", encoding="utf-8") as f:
+                prompts["query_generation"] = split_prompt_template(f.read(), "query_generation")
+        else:
+            prompts["query_generation"] = {"editable_content": "", "template_variables": ""}
+
+        # 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": 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
+
+        default_prompt_path = completion_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("/")
+
+        if graphname:
+            # Create graph-specific prompt dir, seed from default (first time only)
+            graph_prompt_dir = f"common/prompts/{graphname}"
+            os.makedirs(graph_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(graph_prompt_dir, fname)
+                    if os.path.isfile(src) and not os.path.exists(dst):
+                        shutil.copy2(src, dst)
+
+            # Create or update configs/{graphname}/server_config.json
+            graph_config_dir = f"configs/{graphname}"
+            os.makedirs(graph_config_dir, exist_ok=True)
+            graph_config_path = os.path.join(graph_config_dir, "server_config.json")
+            if not os.path.exists(graph_config_path):
+                with open(SERVER_CONFIG, "r") as f:
+                    graph_server_config = json.load(f)
+            else:
+                with open(graph_config_path, "r") as f:
+                    graph_server_config = json.load(f)
+            graph_server_config["llm_config"]["completion_service"]["prompt_path"] = f"./{graph_prompt_dir}/"
+            with open(graph_config_path, "w") as f:
+                json.dump(graph_server_config, f, indent=2)
+
+            prompt_path = graph_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])
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(content)
+
+        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