diff --git a/wavefront/client/src/api/knowledge-base-service.ts b/wavefront/client/src/api/knowledge-base-service.ts
index 95ba6002..2adc22e2 100644
--- a/wavefront/client/src/api/knowledge-base-service.ts
+++ b/wavefront/client/src/api/knowledge-base-service.ts
@@ -9,22 +9,26 @@ export interface NewKnowledgeBasePayload {
   vector_size: number;
 }
 
+// Interface for partially updating a knowledge base
+export interface UpdateKnowledgeBasePayload {
+  name?: string;
+  description?: string;
+  type?: string;
+}
+
 export interface KbData {
   id: string;
   name: string;
   description: string;
+  type: string;
   created_at: string;
   updated_at: string;
 }
-// Interface for knowledge base data
-export interface KnowledgeBaseData {
-  data: KbData;
-}
 
 export type KnowledgeBaseDetail = IApiResponse<KbData>;
 
 // Interface for a single knowledge base response
-export type KnowledgeBaseDetailResponse = IApiResponse<KnowledgeBaseData>;
+export type KnowledgeBaseDetailResponse = IApiResponse<KbData>;
 
 // Interface for listing knowledge bases
 export interface KnowledgeBaseListData {
@@ -96,6 +100,14 @@ export class KnowledgeBaseService {
     return response;
   }
 
+  async updateKnowledgeBase(kbId: string, payload: UpdateKnowledgeBasePayload): Promise<KnowledgeBaseDetailResponse> {
+    const response: KnowledgeBaseDetailResponse = await this.http.patch(
+      `/v1/:appId/floware/v1/knowledge-bases/${kbId}`,
+      payload
+    );
+    return response;
+  }
+
   async listKnowledgeBases(offset: number = 0, limit: number = 10): Promise<KnowledgeBaseListResponse> {
     const response: KnowledgeBaseListResponse = await this.http.get(`/v1/:appId/floware/v1/knowledge-bases`, {
       params: { offset, limit },
diff --git a/wavefront/client/src/components/KnowledgeBaseCard.tsx b/wavefront/client/src/components/KnowledgeBaseCard.tsx
index b244a307..5cd34997 100644
--- a/wavefront/client/src/components/KnowledgeBaseCard.tsx
+++ b/wavefront/client/src/components/KnowledgeBaseCard.tsx
@@ -6,9 +6,10 @@ interface KnowledgeBaseCardProps {
   kb: KbData;
   onClick: (kbId: string) => void;
   onDeleteClick: (e: React.MouseEvent, kb: KbData) => void;
+  onEditClick?: (e: React.MouseEvent, kb: KbData) => void;
 }
 
-const KnowledgeBaseCard: React.FC<KnowledgeBaseCardProps> = ({ kb, onClick, onDeleteClick }) => {
+const KnowledgeBaseCard: React.FC<KnowledgeBaseCardProps> = ({ kb, onClick, onDeleteClick, onEditClick }) => {
   const metadata: ResourceCardMetadata[] = [
     {
       label: 'Knowledge Base ID',
@@ -24,7 +25,9 @@ const KnowledgeBaseCard: React.FC<KnowledgeBaseCardProps> = ({ kb, onClick, onDe
       metadata={metadata}
       onClick={() => onClick(kb.id)}
       onDeleteClick={(e) => onDeleteClick(e, kb)}
+      onEditClick={onEditClick ? (e) => onEditClick(e, kb) : undefined}
       deleteTitle="Delete knowledge base"
+      editTitle="Edit knowledge base"
     />
   );
 };
diff --git a/wavefront/client/src/components/ResourceCard.tsx b/wavefront/client/src/components/ResourceCard.tsx
index 50c84183..13c6ae5f 100644
--- a/wavefront/client/src/components/ResourceCard.tsx
+++ b/wavefront/client/src/components/ResourceCard.tsx
@@ -1,4 +1,4 @@
-import { TrashIcon } from 'lucide-react';
+import { Pencil, TrashIcon } from 'lucide-react';
 import React from 'react';
 
 export interface ResourceCardMetadata {
@@ -14,7 +14,9 @@ interface ResourceCardProps {
   metadata: ResourceCardMetadata[];
   onClick: () => void;
   onDeleteClick: (e: React.MouseEvent) => void;
+  onEditClick?: (e: React.MouseEvent) => void;
   deleteTitle?: string;
+  editTitle?: string;
 }
 
 const ResourceCard: React.FC<ResourceCardProps> = ({
@@ -23,7 +25,9 @@ const ResourceCard: React.FC<ResourceCardProps> = ({
   metadata,
   onClick,
   onDeleteClick,
+  onEditClick,
   deleteTitle = 'Delete',
+  editTitle = 'Edit',
 }) => {
   return (
     <div
@@ -35,6 +39,15 @@ const ResourceCard: React.FC<ResourceCardProps> = ({
           {title}
         </h3>
         <div className="flex items-center space-x-2">
+          {onEditClick && (
+            <button
+              onClick={onEditClick}
+              className="cursor-pointer rounded p-1 text-gray-600 opacity-0 transition-opacity group-hover:opacity-100 hover:bg-gray-100 hover:text-gray-900"
+              title={editTitle}
+            >
+              <Pencil className="h-4 w-4" />
+            </button>
+          )}
           <button
             onClick={onDeleteClick}
             className="cursor-pointer rounded p-1 text-red-500 opacity-0 transition-opacity group-hover:opacity-100 hover:bg-red-50 hover:text-red-700"
diff --git a/wavefront/client/src/pages/apps/[appId]/knowledge-bases/CreateKnowledgeBaseDialog.tsx b/wavefront/client/src/pages/apps/[appId]/knowledge-bases/CreateKnowledgeBaseDialog.tsx
index 5a507ac3..db44f4cc 100644
--- a/wavefront/client/src/pages/apps/[appId]/knowledge-bases/CreateKnowledgeBaseDialog.tsx
+++ b/wavefront/client/src/pages/apps/[appId]/knowledge-bases/CreateKnowledgeBaseDialog.tsx
@@ -23,7 +23,6 @@ import { useDashboardStore, useNotifyStore } from '@app/store';
 import { zodResolver } from '@hookform/resolvers/zod';
 import React, { useEffect } from 'react';
 import { useForm } from 'react-hook-form';
-import { useNavigate } from 'react-router';
 import { z } from 'zod';
 
 const createKnowledgeBaseSchema = z.object({
@@ -48,7 +47,6 @@ const CreateKnowledgeBaseDialog: React.FC<CreateKnowledgeBaseDialogProps> = ({
   appId,
   onSuccess,
 }) => {
-  const navigate = useNavigate();
   const { notifySuccess, notifyError } = useNotifyStore();
   const { selectedApp } = useDashboardStore();
 
@@ -91,18 +89,9 @@ const CreateKnowledgeBaseDialog: React.FC<CreateKnowledgeBaseDialogProps> = ({
       const response = await floConsoleService.knowledgeBaseService.createKnowledgeBase(payload);
 
       if (response.data?.data) {
-        notifySuccess(`Knowledge Base '${response.data.data.data.name}' created successfully`);
-
-        if (onSuccess) {
-          onSuccess();
-        }
-
+        notifySuccess(`Knowledge Base '${response.data.data.name}' created successfully`);
+        onSuccess?.();
         onOpenChange(false);
-
-        // Navigate to the created knowledge base
-        if (response.data.data.data.id) {
-          navigate(`/apps/${appId}/knowledge-bases/${response.data.data.data.id}`);
-        }
       } else {
         notifyError('Failed to get knowledge base ID after creation.');
       }
diff --git a/wavefront/client/src/pages/apps/[appId]/knowledge-bases/EditKnowledgeBaseDialog.tsx b/wavefront/client/src/pages/apps/[appId]/knowledge-bases/EditKnowledgeBaseDialog.tsx
new file mode 100644
index 00000000..dffa92a8
--- /dev/null
+++ b/wavefront/client/src/pages/apps/[appId]/knowledge-bases/EditKnowledgeBaseDialog.tsx
@@ -0,0 +1,172 @@
+import floConsoleService from '@app/api';
+import { KbData, UpdateKnowledgeBasePayload } from '@app/api/knowledge-base-service';
+import { Button } from '@app/components/ui/button';
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from '@app/components/ui/dialog';
+import {
+  Form,
+  FormControl,
+  FormDescription,
+  FormField,
+  FormItem,
+  FormLabel,
+  FormMessage,
+} from '@app/components/ui/form';
+import { Input } from '@app/components/ui/input';
+import { extractErrorMessage } from '@app/lib/utils';
+import { useNotifyStore } from '@app/store';
+import { zodResolver } from '@hookform/resolvers/zod';
+import React, { useEffect } from 'react';
+import { useForm } from 'react-hook-form';
+import { z } from 'zod';
+
+const editKnowledgeBaseSchema = z.object({
+  name: z.string().min(1, 'Knowledge base name is required'),
+  type: z.string().min(1, 'Type is required'),
+  description: z.string().optional(),
+});
+
+type EditKnowledgeBaseInput = z.infer<typeof editKnowledgeBaseSchema>;
+
+interface EditKnowledgeBaseDialogProps {
+  isOpen: boolean;
+  onOpenChange: (open: boolean) => void;
+  knowledgeBase: KbData;
+  onSuccess?: () => void;
+}
+
+const EditKnowledgeBaseDialog: React.FC<EditKnowledgeBaseDialogProps> = ({
+  isOpen,
+  onOpenChange,
+  knowledgeBase,
+  onSuccess,
+}) => {
+  const { notifySuccess, notifyError } = useNotifyStore();
+
+  const form = useForm<EditKnowledgeBaseInput>({
+    resolver: zodResolver(editKnowledgeBaseSchema),
+    defaultValues: {
+      name: '',
+      type: '',
+      description: '',
+    },
+  });
+
+  useEffect(() => {
+    if (knowledgeBase && isOpen) {
+      form.reset({
+        name: knowledgeBase.name || '',
+        type: knowledgeBase.type || '',
+        description: knowledgeBase.description || '',
+      });
+    }
+  }, [knowledgeBase, isOpen, form]);
+
+  const onSubmit = async (data: EditKnowledgeBaseInput) => {
+    try {
+      const payload: UpdateKnowledgeBasePayload = {
+        name: data.name.trim(),
+        description: data.description?.trim() || '',
+        type: data.type.trim(),
+      };
+
+      await floConsoleService.knowledgeBaseService.updateKnowledgeBase(knowledgeBase.id, payload);
+
+      notifySuccess(`Knowledge Base '${payload.name}' updated successfully`);
+      onSuccess?.();
+      onOpenChange(false);
+    } catch (error) {
+      console.error('Error updating knowledge base:', error);
+      const errorMessage = extractErrorMessage(error);
+      notifyError(errorMessage || 'Failed to update knowledge base');
+    }
+  };
+
+  return (
+    <Dialog open={isOpen} onOpenChange={onOpenChange}>
+      <DialogContent className="max-h-[90vh] max-w-4xl overflow-y-auto lg:max-w-4xl">
+        <DialogHeader>
+          <DialogTitle>Edit Knowledge Base</DialogTitle>
+          <DialogDescription>Update the details for this knowledge base</DialogDescription>
+        </DialogHeader>
+
+        <Form {...form}>
+          <form onSubmit={form.handleSubmit(onSubmit)} className="space-y-6">
+            <div className="grid grid-cols-2 gap-6">
+              <FormField
+                control={form.control}
+                name="name"
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>
+                      Knowledge Base Name<span className="text-red-500">*</span>
+                    </FormLabel>
+                    <FormControl>
+                      <Input placeholder="e.g., Customer Support FAQ" {...field} />
+                    </FormControl>
+                    <FormDescription>A unique name for your knowledge base</FormDescription>
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+
+              <FormField
+                control={form.control}
+                name="type"
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>
+                      Type<span className="text-red-500">*</span>
+                    </FormLabel>
+                    <FormControl>
+                      <Input placeholder="e.g., General" {...field} />
+                    </FormControl>
+                    <FormDescription>The type of your knowledge base</FormDescription>
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+            </div>
+
+            <FormField
+              control={form.control}
+              name="description"
+              render={({ field }) => (
+                <FormItem>
+                  <FormLabel>Description</FormLabel>
+                  <FormControl>
+                    <textarea
+                      rows={3}
+                      placeholder="A brief description of the knowledge base's purpose"
+                      className="border-input bg-background ring-offset-background placeholder:text-muted-foreground focus-visible:ring-ring flex min-h-[80px] w-full rounded-md border px-3 py-2 text-sm focus-visible:ring-2 focus-visible:ring-offset-2 focus-visible:outline-none disabled:cursor-not-allowed disabled:opacity-50"
+                      {...field}
+                    />
+                  </FormControl>
+                  <FormDescription>Provide a description for your knowledge base</FormDescription>
+                  <FormMessage />
+                </FormItem>
+              )}
+            />
+
+            <DialogFooter>
+              <Button type="button" variant="outline" onClick={() => onOpenChange(false)}>
+                Cancel
+              </Button>
+              <Button type="submit" loading={form.formState.isSubmitting}>
+                Save Changes
+              </Button>
+            </DialogFooter>
+          </form>
+        </Form>
+      </DialogContent>
+    </Dialog>
+  );
+};
+
+export default EditKnowledgeBaseDialog;
diff --git a/wavefront/client/src/pages/apps/[appId]/knowledge-bases/index.tsx b/wavefront/client/src/pages/apps/[appId]/knowledge-bases/index.tsx
index d929c301..9118d455 100644
--- a/wavefront/client/src/pages/apps/[appId]/knowledge-bases/index.tsx
+++ b/wavefront/client/src/pages/apps/[appId]/knowledge-bases/index.tsx
@@ -21,6 +21,7 @@ import { useQueryClient } from '@tanstack/react-query';
 import React, { useState } from 'react';
 import { useNavigate, useParams } from 'react-router';
 import CreateKnowledgeBaseDialog from './CreateKnowledgeBaseDialog';
+import EditKnowledgeBaseDialog from './EditKnowledgeBaseDialog';
 
 const KnowledgeBasesListPage: React.FC = () => {
   const { app: appId } = useParams<{ app: string }>();
@@ -32,6 +33,7 @@ const KnowledgeBasesListPage: React.FC = () => {
   const [deleteItem, setDeleteItem] = useState<KbData | null>(null);
   const [deleting, setDeleting] = useState(false);
   const [createDialogOpen, setCreateDialogOpen] = useState(false);
+  const [editItem, setEditItem] = useState<KbData | null>(null);
 
   // Fetch knowledge bases
   const { data: knowledgeBases = [], isLoading: loading } = useGetKnowledgeBases(appId);
@@ -41,6 +43,16 @@ const KnowledgeBasesListPage: React.FC = () => {
     setDeleteItem(kb);
   };
 
+  const handleEditClick = (e: React.MouseEvent, kb: KbData) => {
+    e.stopPropagation();
+    setEditItem(kb);
+  };
+
+  const handleEditSuccess = () => {
+    queryClient.invalidateQueries({ queryKey: getKnowledgeBasesKey(appId as string) });
+    setEditItem(null);
+  };
+
   const handleDeleteConfirm = async () => {
     if (!appId || !deleteItem) return;
 
@@ -72,8 +84,7 @@ const KnowledgeBasesListPage: React.FC = () => {
   };
 
   const handleCreateSuccess = () => {
-    if (!appId) return;
-    queryClient.invalidateQueries({ queryKey: getKnowledgeBasesKey(appId) });
+    queryClient.invalidateQueries({ queryKey: getKnowledgeBasesKey(appId as string) });
     setCreateDialogOpen(false);
   };
 
@@ -143,7 +154,13 @@ const KnowledgeBasesListPage: React.FC = () => {
         ) : (
           <>
             {filteredKnowledgeBases.map((kb) => (
-              <KnowledgeBaseCard key={kb.id} kb={kb} onClick={handleCardClick} onDeleteClick={handleDeleteClick} />
+              <KnowledgeBaseCard
+                key={kb.id}
+                kb={kb}
+                onClick={handleCardClick}
+                onDeleteClick={handleDeleteClick}
+                onEditClick={handleEditClick}
+              />
             ))}
           </>
         )}
@@ -168,6 +185,18 @@ const KnowledgeBasesListPage: React.FC = () => {
           onSuccess={handleCreateSuccess}
         />
       )}
+
+      {/* Edit Knowledge Base Dialog */}
+      {editItem && (
+        <EditKnowledgeBaseDialog
+          isOpen={!!editItem}
+          onOpenChange={(open) => {
+            if (!open) setEditItem(null);
+          }}
+          knowledgeBase={editItem}
+          onSuccess={handleEditSuccess}
+        />
+      )}
     </div>
   );
 };
diff --git a/wavefront/client/src/pages/apps/layout.tsx b/wavefront/client/src/pages/apps/layout.tsx
index 477d2b51..2dc7640c 100644
--- a/wavefront/client/src/pages/apps/layout.tsx
+++ b/wavefront/client/src/pages/apps/layout.tsx
@@ -74,7 +74,7 @@ const navItems = [
   },
   {
     id: 'knowledge-bases',
-    name: 'RAG Service',
+    name: 'Knowledgebases',
     icon: RagIcon,
     link: `/apps/:appId/knowledge-bases`,
     description: 'Manage and configure knowledge bases for this application',
diff --git a/wavefront/server/apps/floware/floware/controllers/config_controller.py b/wavefront/server/apps/floware/floware/controllers/config_controller.py
index 4cbd85de..5705b492 100644
--- a/wavefront/server/apps/floware/floware/controllers/config_controller.py
+++ b/wavefront/server/apps/floware/floware/controllers/config_controller.py
@@ -8,9 +8,6 @@
 from fastapi.params import Depends
 from dependency_injector.wiring import inject
 from dependency_injector.wiring import Provide
-from db_repo_module.models.datasource import Datasource
-from db_repo_module.repositories.sql_alchemy_repository import SQLAlchemyRepository
-from plugins_module.plugins_container import PluginsContainer
 from floware.services.config_service import ConfigService
 from user_management_module.utils.user_utils import get_current_user, check_is_admin
 from fastapi import HTTPException
@@ -77,10 +74,6 @@ async def get_config(
         ConfigService,
         Depends(Provide[ApplicationContainer.config_service]),
     ],
-    datasource_repository: Annotated[
-        SQLAlchemyRepository[Datasource],
-        Depends(Provide[PluginsContainer.datasource_repository]),
-    ],
     response_formatter: Annotated[
         ResponseFormatter,
         Depends(Provide[CommonContainer.response_formatter]),
@@ -90,17 +83,9 @@ async def get_config(
     this endpoint will return all the configuration of the application.
     such as logo, table to query, etc.
     """
-    url, app_config = await config_service.get_app_config()
-    datasources = await datasource_repository.find()
-    datasource_ids = [str(datasource.id) for datasource in datasources]
+    settings = await config_service.get_settings_config()
 
     return JSONResponse(
         status_code=status.HTTP_200_OK,
-        content=response_formatter.buildSuccessResponse(
-            {
-                'app_icon': url,
-                'app_config': app_config,
-                'datasources': datasource_ids,
-            }
-        ),
+        content=response_formatter.buildSuccessResponse(settings),
     )
diff --git a/wavefront/server/apps/floware/floware/di/application_container.py b/wavefront/server/apps/floware/floware/di/application_container.py
index b764703c..73a40bd6 100644
--- a/wavefront/server/apps/floware/floware/di/application_container.py
+++ b/wavefront/server/apps/floware/floware/di/application_container.py
@@ -1,6 +1,9 @@
 from dependency_injector import containers
 from dependency_injector import providers
 
+from floware.repositories.config_repository import AppConfigRepository
+from floware.repositories.datasource_repository import AppDatasourceRepository
+from floware.repositories.knowledge_base_repository import AppKnowledgeBaseRepository
 from floware.services.notification_service import NotificationService
 from floware.services.config_service import ConfigService
 from floware.services.scheduled_job_service import ScheduledJobService
@@ -10,6 +13,7 @@ class ApplicationContainer(containers.DeclarativeContainer):
     config = providers.Configuration(ini_files=['./config.ini'])
     # db
     db_client = providers.Dependency()
+    cache_manager = providers.Dependency()
 
     email_repository = providers.Dependency()
     oauth_credential_repository = providers.Dependency()
@@ -28,6 +32,23 @@ class ApplicationContainer(containers.DeclarativeContainer):
     user_service = providers.Dependency()
     role_repository = providers.Dependency()
     user_role_repository = providers.Dependency()
+    knowledge_base_repository = providers.Dependency()
+
+    app_config_repository = providers.Singleton(
+        AppConfigRepository,
+        repository=config_repository,
+        cache_manager=cache_manager,
+    )
+    app_datasource_repository = providers.Singleton(
+        AppDatasourceRepository,
+        repository=datasource_repository,
+        cache_manager=cache_manager,
+    )
+    app_knowledge_base_repository = providers.Singleton(
+        AppKnowledgeBaseRepository,
+        repository=knowledge_base_repository,
+        cache_manager=cache_manager,
+    )
 
     # services
     notification_service = providers.Singleton(
@@ -36,7 +57,9 @@ class ApplicationContainer(containers.DeclarativeContainer):
 
     config_service = providers.Singleton(
         ConfigService,
-        config_repository=config_repository,
+        app_config_repository=app_config_repository,
+        datasource_repository=app_datasource_repository,
+        knowledge_base_repository=app_knowledge_base_repository,
         cloud_storage_manager=cloud_storage_manager,
         config=config,
     )
diff --git a/wavefront/server/apps/floware/floware/repositories/__init__.py b/wavefront/server/apps/floware/floware/repositories/__init__.py
new file mode 100644
index 00000000..67282098
--- /dev/null
+++ b/wavefront/server/apps/floware/floware/repositories/__init__.py
@@ -0,0 +1,11 @@
+from floware.repositories.config_repository import AppConfigRepository
+from floware.repositories.base_cached_repository import BaseCachedRepository
+from floware.repositories.datasource_repository import AppDatasourceRepository
+from floware.repositories.knowledge_base_repository import AppKnowledgeBaseRepository
+
+__all__ = [
+    'AppConfigRepository',
+    'AppDatasourceRepository',
+    'AppKnowledgeBaseRepository',
+    'BaseCachedRepository',
+]
diff --git a/wavefront/server/apps/floware/floware/repositories/base_cached_repository.py b/wavefront/server/apps/floware/floware/repositories/base_cached_repository.py
new file mode 100644
index 00000000..7027aa3c
--- /dev/null
+++ b/wavefront/server/apps/floware/floware/repositories/base_cached_repository.py
@@ -0,0 +1,40 @@
+import json
+from typing import Any, Generic, Optional, TypeVar
+
+from common_module.log.logger import logger
+from db_repo_module.cache.application_cache import APPLICATION_CACHE_TTL_SECONDS
+from db_repo_module.cache.cache_manager import CacheManager
+from db_repo_module.repositories.sql_alchemy_repository import SQLAlchemyRepository
+
+T = TypeVar('T')
+
+
+class BaseCachedRepository(Generic[T]):
+    """Shared Redis cache helpers for application repositories."""
+
+    def __init__(
+        self,
+        repository: SQLAlchemyRepository[T],
+        cache_manager: CacheManager,
+    ) -> None:
+        self.repository = repository
+        self.cache_manager = cache_manager
+
+    def _read_cache(self, key: str) -> Optional[Any]:
+        try:
+            cached = self.cache_manager.get_str(key)
+            if cached is not None:
+                return json.loads(cached)
+        except Exception as e:
+            logger.warning(f'Cache read failed for {key}: {e}')
+        return None
+
+    def _write_cache(self, key: str, value: Any) -> None:
+        try:
+            self.cache_manager.add(
+                key,
+                json.dumps(value),
+                expiry=APPLICATION_CACHE_TTL_SECONDS,
+            )
+        except Exception as e:
+            logger.warning(f'Cache write failed for {key}: {e}')
diff --git a/wavefront/server/apps/floware/floware/repositories/config_repository.py b/wavefront/server/apps/floware/floware/repositories/config_repository.py
new file mode 100644
index 00000000..5cc6fdcd
--- /dev/null
+++ b/wavefront/server/apps/floware/floware/repositories/config_repository.py
@@ -0,0 +1,30 @@
+from typing import Any, Optional
+
+from db_repo_module.cache.application_cache import (
+    APP_CONFIG_CACHE_KEY,
+    invalidate_app_config_cache,
+)
+from db_repo_module.models.config import Config
+from floware.repositories.base_cached_repository import BaseCachedRepository
+
+
+class AppConfigRepository(BaseCachedRepository[Config]):
+    async def get(self) -> Optional[dict[str, Any]]:
+        cached = self._read_cache(APP_CONFIG_CACHE_KEY)
+        if cached is not None:
+            return cached
+
+        config_records = await self.repository.find(key='app_config')
+        if not config_records:
+            return None
+
+        value = config_records[0].value or {}
+        self._write_cache(APP_CONFIG_CACHE_KEY, value)
+        return value
+
+    async def upsert(self, value: dict[str, Any]) -> None:
+        await self.repository.upsert(
+            filters={'key': 'app_config'},
+            value=value,
+        )
+        invalidate_app_config_cache(self.cache_manager)
diff --git a/wavefront/server/apps/floware/floware/repositories/datasource_repository.py b/wavefront/server/apps/floware/floware/repositories/datasource_repository.py
new file mode 100644
index 00000000..e53f1b14
--- /dev/null
+++ b/wavefront/server/apps/floware/floware/repositories/datasource_repository.py
@@ -0,0 +1,19 @@
+from typing import Any
+
+from db_repo_module.cache.application_cache import DATASOURCES_CACHE_KEY
+from db_repo_module.models.datasource import Datasource
+from floware.repositories.base_cached_repository import BaseCachedRepository
+
+
+class AppDatasourceRepository(BaseCachedRepository[Datasource]):
+    async def get_all(self) -> list[dict[str, Any]]:
+        cached = self._read_cache(DATASOURCES_CACHE_KEY)
+        if cached is not None:
+            return cached
+
+        datasources = await self.repository.find()
+        payload = [
+            datasource.to_dict(exclude_config=True) for datasource in datasources
+        ]
+        self._write_cache(DATASOURCES_CACHE_KEY, payload)
+        return payload
diff --git a/wavefront/server/apps/floware/floware/repositories/knowledge_base_repository.py b/wavefront/server/apps/floware/floware/repositories/knowledge_base_repository.py
new file mode 100644
index 00000000..0af528ce
--- /dev/null
+++ b/wavefront/server/apps/floware/floware/repositories/knowledge_base_repository.py
@@ -0,0 +1,17 @@
+from typing import Any
+
+from db_repo_module.cache.application_cache import KNOWLEDGE_BASES_CACHE_KEY
+from db_repo_module.models.knowledge_bases import KnowledgeBase
+from floware.repositories.base_cached_repository import BaseCachedRepository
+
+
+class AppKnowledgeBaseRepository(BaseCachedRepository[KnowledgeBase]):
+    async def get_all(self) -> list[dict[str, Any]]:
+        cached = self._read_cache(KNOWLEDGE_BASES_CACHE_KEY)
+        if cached is not None:
+            return cached
+
+        knowledge_bases = await self.repository.find()
+        payload = [knowledge_base.to_dict() for knowledge_base in knowledge_bases]
+        self._write_cache(KNOWLEDGE_BASES_CACHE_KEY, payload)
+        return payload
diff --git a/wavefront/server/apps/floware/floware/server.py b/wavefront/server/apps/floware/floware/server.py
index d72130de..da58bd85 100644
--- a/wavefront/server/apps/floware/floware/server.py
+++ b/wavefront/server/apps/floware/floware/server.py
@@ -126,6 +126,7 @@
 )
 application_container = ApplicationContainer(
     db_client=db_repo_container.db_client,
+    cache_manager=db_repo_container.cache_manager,
     cloud_storage_manager=common_container.cloud_storage_manager,
     email_repository=db_repo_container.email_repository,
     oauth_credential_repository=db_repo_container.oauth_credential_repository,
@@ -142,9 +143,10 @@
     user_service=user_module_container.user_service,
     role_repository=user_module_container.role_repository,
     user_role_repository=user_module_container.user_role_repository,
+    knowledge_base_repository=db_repo_container.knowledge_base_repository,
 )
 
-email_rag_container = KnowledgeBaseContainer(
+knowledge_base_container = KnowledgeBaseContainer(
     db_client=db_repo_container.db_client, cache_manager=db_repo_container.cache_manager
 )
 
@@ -557,7 +559,7 @@ async def global_exception_handler(request: Request, exc: Exception):
     ],
 )
 
-email_rag_container.wire(
+knowledge_base_container.wire(
     modules=[__name__],
     packages=[
         'knowledge_base_module.controllers',
diff --git a/wavefront/server/apps/floware/floware/services/config_service.py b/wavefront/server/apps/floware/floware/services/config_service.py
index 9f4ad86d..431cf61d 100644
--- a/wavefront/server/apps/floware/floware/services/config_service.py
+++ b/wavefront/server/apps/floware/floware/services/config_service.py
@@ -1,19 +1,24 @@
 from typing import Any
 
-from db_repo_module.models.config import Config
 from fastapi import UploadFile, File, HTTPException
 from flo_cloud.cloud_storage import CloudStorageManager
-from db_repo_module.repositories.sql_alchemy_repository import SQLAlchemyRepository
+from floware.repositories.config_repository import AppConfigRepository
+from floware.repositories.datasource_repository import AppDatasourceRepository
+from floware.repositories.knowledge_base_repository import AppKnowledgeBaseRepository
 
 
 class ConfigService:
     def __init__(
         self,
-        config_repository: SQLAlchemyRepository[Config],
+        app_config_repository: AppConfigRepository,
+        datasource_repository: AppDatasourceRepository,
+        knowledge_base_repository: AppKnowledgeBaseRepository,
         cloud_storage_manager: CloudStorageManager,
         config: dict[str, Any],
     ) -> None:
-        self.config_repository = config_repository
+        self.app_config_repository = app_config_repository
+        self.datasource_repository = datasource_repository
+        self.knowledge_base_repository = knowledge_base_repository
         self.cloud_storage_manager = cloud_storage_manager
         self.config = config
 
@@ -52,34 +57,40 @@ async def store_app_config(
                 config_credentials['config_file_name'],
             )
         # if atleast one icon or file_content is there then allow the all_config to be saved
-        config_data = await self.config_repository.find(key='app_config')
-        if config_data and config_data[0].value.get('app_icon') or file_content:
-            # saving the config to the database
-            await self.config_repository.upsert(
-                filters={'key': 'app_config'},
-                value={
+        config_data = await self.app_config_repository.get()
+        if config_data and config_data.get('app_icon') or file_content:
+            await self.app_config_repository.upsert(
+                {
                     'app_icon': config_credentials['config_file_name'],
                     'app_config': app_config if app_config else {},
-                },
+                }
             )
         else:
             raise HTTPException(status_code=400, detail='App icon is not set')
         return
 
     async def get_app_config(self):
-        config_record = await self.config_repository.find(key='app_config')
-        # checking if the config_record is empty
+        config_record = await self.app_config_repository.get()
         if not config_record:
             return None, None
-        config_path = config_record[0].value.get('app_icon')
+        config_path = config_record.get('app_icon')
         config_credentials = self._get_floware_credentials()
-        # Generate new presigned URL
         url = self.cloud_storage_manager.generate_presigned_url(
             config_credentials['asset_storage_bucket'],
             config_path,
             'get',
         )
-        # getting the app_config from the database
-        app_config = config_record[0].value.get('app_config', {})
-
+        app_config = config_record.get('app_config', {})
         return url, app_config
+
+    async def get_settings_config(self) -> dict[str, Any]:
+        """Full settings/config payload: app icon URL, app_config, and resource lists."""
+        url, app_config = await self.get_app_config()
+        datasources = await self.datasource_repository.get_all()
+        knowledge_bases = await self.knowledge_base_repository.get_all()
+        return {
+            'app_icon': url,
+            'app_config': app_config,
+            'datasources': datasources,
+            'knowledgebases': knowledge_bases,
+        }
diff --git a/wavefront/server/apps/floware/tests/conftest.py b/wavefront/server/apps/floware/tests/conftest.py
index 790393f2..e46cbf14 100644
--- a/wavefront/server/apps/floware/tests/conftest.py
+++ b/wavefront/server/apps/floware/tests/conftest.py
@@ -195,8 +195,17 @@ async def mock_store_app_config(file, app_config_dict):
     async def mock_get_app_config():
         return 'https://test-bucket.com/config.png', {}
 
+    async def mock_get_settings_config():
+        return {
+            'app_icon': 'https://test-bucket.com/config.png',
+            'app_config': {},
+            'datasources': [],
+            'knowledge_bases': [],
+        }
+
     mock_service.store_app_config = mock_store_app_config
     mock_service.get_app_config = mock_get_app_config
+    mock_service.get_settings_config = mock_get_settings_config
 
     return mock_service
 
diff --git a/wavefront/server/modules/db_repo_module/db_repo_module/cache/application_cache.py b/wavefront/server/modules/db_repo_module/db_repo_module/cache/application_cache.py
new file mode 100644
index 00000000..7fc23ba5
--- /dev/null
+++ b/wavefront/server/modules/db_repo_module/db_repo_module/cache/application_cache.py
@@ -0,0 +1,34 @@
+"""Shared application cache keys for settings/config resource lists.
+
+CacheManager is constructed with namespace=app_name, so keys are stored as
+`{app_name}/{key}` in Redis. Keep these keys app-agnostic so any deployment
+can share the same helpers.
+"""
+
+from common_module.log.logger import logger
+from db_repo_module.cache.cache_manager import CacheManager
+
+APP_CONFIG_CACHE_KEY = 'app_config'
+DATASOURCES_CACHE_KEY = 'datasources'
+KNOWLEDGE_BASES_CACHE_KEY = 'knowledge_bases'
+APPLICATION_CACHE_TTL_SECONDS = 60 * 60
+
+
+def _invalidate(cache_manager: CacheManager, key: str, label: str) -> None:
+    try:
+        cache_manager.remove(key)
+    except Exception as e:
+        # A stale entry is recoverable via TTL; failing a write after commit is not.
+        logger.warning(f'Failed to invalidate {label} cache: {e}')
+
+
+def invalidate_app_config_cache(cache_manager: CacheManager) -> None:
+    _invalidate(cache_manager, APP_CONFIG_CACHE_KEY, 'app config')
+
+
+def invalidate_datasources_cache(cache_manager: CacheManager) -> None:
+    _invalidate(cache_manager, DATASOURCES_CACHE_KEY, 'datasources')
+
+
+def invalidate_knowledge_bases_cache(cache_manager: CacheManager) -> None:
+    _invalidate(cache_manager, KNOWLEDGE_BASES_CACHE_KEY, 'knowledge bases')
diff --git a/wavefront/server/modules/db_repo_module/db_repo_module/models/datasource.py b/wavefront/server/modules/db_repo_module/db_repo_module/models/datasource.py
index 7c8e4362..0847caeb 100644
--- a/wavefront/server/modules/db_repo_module/db_repo_module/models/datasource.py
+++ b/wavefront/server/modules/db_repo_module/db_repo_module/models/datasource.py
@@ -32,9 +32,13 @@ class Datasource(Base):
     def get_table_name():
         return (Datasource()).__tablename__
 
-    def to_dict(self):
+    def to_dict(self, exclude_config: bool = False):
         result = {}
         for column in self.__table__.columns:
+            # Skip config in responses for security
+            if exclude_config and column.name == 'config':
+                continue
+
             value = getattr(self, column.name)
             if isinstance(value, uuid.UUID):
                 result[column.name] = str(value)
diff --git a/wavefront/server/modules/knowledge_base_module/knowledge_base_module/controllers/knowledge_base_controller.py b/wavefront/server/modules/knowledge_base_module/knowledge_base_module/controllers/knowledge_base_controller.py
index e1facbe3..91917c72 100644
--- a/wavefront/server/modules/knowledge_base_module/knowledge_base_module/controllers/knowledge_base_controller.py
+++ b/wavefront/server/modules/knowledge_base_module/knowledge_base_module/controllers/knowledge_base_controller.py
@@ -3,6 +3,10 @@
 
 from common_module.common_container import CommonContainer
 from common_module.response_formatter import ResponseFormatter
+from db_repo_module.cache.cache_manager import CacheManager
+from db_repo_module.cache.application_cache import (
+    invalidate_knowledge_bases_cache,
+)
 from db_repo_module.models.knowledge_bases import KnowledgeBase
 from db_repo_module.repositories.sql_alchemy_repository import SQLAlchemyRepository
 from dependency_injector.wiring import inject
@@ -15,6 +19,7 @@
 from fastapi.responses import JSONResponse
 from knowledge_base_module.knowledge_base_container import KnowledgeBaseContainer
 from knowledge_base_module.models.knowledge_base_schema import NewKnowledge
+from knowledge_base_module.models.knowledge_base_schema import UpdateKnowledge
 from pydantic import BaseModel
 from sqlalchemy import Result
 from sqlalchemy import select
@@ -43,6 +48,9 @@ async def create_knowledge_base(
     knowledge_base_repository: SQLAlchemyRepository[KnowledgeBase] = Depends(
         Provide[KnowledgeBaseContainer.knowledge_base_repository]
     ),
+    cache_manager: CacheManager = Depends(
+        Provide[KnowledgeBaseContainer.cache_manager]
+    ),
 ) -> JSONResponse:
     """Create a new knowledge base."""
     # Check for existing knowledge base
@@ -58,28 +66,26 @@ async def create_knowledge_base(
         )
 
     # Create new knowledge base
-    async with knowledge_base_repository.session() as session:
-        new_kb = KnowledgeBase(
-            name=new_base.name,
-            description=new_base.description,
-            type=new_base.type,
-            vector_size=new_base.vector_size,
-            vector_size_1=new_base.vector_size_1 if new_base.vector_size_1 else None,
-        )
-        session.add(new_kb)
-        await session.flush()
-        new_kb_id = new_kb.id
-        await session.commit()
+    new_kb = await knowledge_base_repository.create(
+        name=new_base.name,
+        description=new_base.description,
+        type=new_base.type,
+        vector_size=new_base.vector_size,
+        vector_size_1=new_base.vector_size_1 if new_base.vector_size_1 else None,
+    )
+    invalidate_knowledge_bases_cache(cache_manager)
 
-        return JSONResponse(
-            status_code=status.HTTP_200_OK,
-            content=response_formatter.buildSuccessResponse(
-                {
-                    'message': 'Created the knowledge base successfully',
-                    'knowledge_base_id': str(new_kb_id),
-                }
-            ),
-        )
+    return JSONResponse(
+        status_code=status.HTTP_200_OK,
+        content=response_formatter.buildSuccessResponse(
+            {
+                'id': str(new_kb.id),
+                'name': new_kb.name,
+                'created_at': new_kb.created_at.isoformat(),
+                'updated_at': new_kb.updated_at.isoformat(),
+            }
+        ),
+    )
 
 
 @knowledge_base_router.get('/v1/knowledge-bases/{kb_id}')
@@ -136,19 +142,22 @@ async def get_knowledge_bases(
         )
 
 
-@knowledge_base_router.put('/v1/knowledge-bases/{kb_id}')
+@knowledge_base_router.patch('/v1/knowledge-bases/{kb_id}')
 @inject
 async def update_knowledge_bases(
     kb_id: uuid.UUID,
-    new_base: NewKnowledge,
+    update_base: UpdateKnowledge,
     response_formatter: ResponseFormatter = Depends(
         Provide[CommonContainer.response_formatter]
     ),
     knowledge_base_repository: SQLAlchemyRepository[KnowledgeBase] = Depends(
         Provide[KnowledgeBaseContainer.knowledge_base_repository]
     ),
+    cache_manager: CacheManager = Depends(
+        Provide[KnowledgeBaseContainer.cache_manager]
+    ),
 ) -> JSONResponse:
-    """Update an existing knowledge base."""
+    """Partially update an existing knowledge base."""
     existing_kb = await knowledge_base_repository.find_one(id=kb_id)
     if not existing_kb:
         return JSONResponse(
@@ -158,20 +167,45 @@ async def update_knowledge_bases(
             ),
         )
 
-    await knowledge_base_repository.find_one_and_update(
+    update_kwargs = {}
+    if update_base.name is not None:
+        if update_base.name != existing_kb.name:
+            duplicate_kb = await knowledge_base_repository.find_one(
+                name=update_base.name
+            )
+            if duplicate_kb:
+                return JSONResponse(
+                    status_code=status.HTTP_400_BAD_REQUEST,
+                    content=response_formatter.buildErrorResponse(
+                        'Knowledge Base with the same name already exists'
+                    ),
+                )
+        update_kwargs['name'] = update_base.name
+    if update_base.description is not None:
+        update_kwargs['description'] = update_base.description
+    if update_base.type is not None:
+        update_kwargs['type'] = update_base.type
+
+    if not update_kwargs:
+        return JSONResponse(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            content=response_formatter.buildErrorResponse(
+                'No fields provided to update'
+            ),
+        )
+
+    update_kwargs['updated_at'] = datetime.now()
+    updated_kb = await knowledge_base_repository.find_one_and_update(
         {'id': kb_id},
-        name=new_base.name,
-        description=new_base.description,
-        type=new_base.type,
+        refresh=True,
+        **update_kwargs,
     )
+    invalidate_knowledge_bases_cache(cache_manager)
 
     return JSONResponse(
         status_code=status.HTTP_200_OK,
         content=response_formatter.buildSuccessResponse(
-            {
-                'message': 'Updated the Knowledge Base successfully',
-                'knowledge_base_id': str(kb_id),
-            }
+            data=updated_kb.to_dict() if updated_kb else {'id': str(kb_id)}
         ),
     )
 
@@ -186,6 +220,9 @@ async def delete_knowledge_base(
     knowledge_base_repository: SQLAlchemyRepository[KnowledgeBase] = Depends(
         Provide[KnowledgeBaseContainer.knowledge_base_repository]
     ),
+    cache_manager: CacheManager = Depends(
+        Provide[KnowledgeBaseContainer.cache_manager]
+    ),
 ) -> JSONResponse:
     """Delete a knowledge base."""
     existing_kb = await knowledge_base_repository.find_one(id=kb_id)
@@ -198,6 +235,7 @@ async def delete_knowledge_base(
         )
 
     await knowledge_base_repository.delete_all(id=kb_id)
+    invalidate_knowledge_bases_cache(cache_manager)
 
     return JSONResponse(
         status_code=status.HTTP_204_NO_CONTENT,
diff --git a/wavefront/server/modules/knowledge_base_module/knowledge_base_module/models/knowledge_base_schema.py b/wavefront/server/modules/knowledge_base_module/knowledge_base_module/models/knowledge_base_schema.py
index abcdb207..b55aa7ad 100644
--- a/wavefront/server/modules/knowledge_base_module/knowledge_base_module/models/knowledge_base_schema.py
+++ b/wavefront/server/modules/knowledge_base_module/knowledge_base_module/models/knowledge_base_schema.py
@@ -10,5 +10,11 @@ class NewKnowledge(BaseModel):
     vector_size_1: Optional[int] = None
 
 
+class UpdateKnowledge(BaseModel):
+    name: Optional[str] = None
+    description: Optional[str] = None
+    type: Optional[str] = None
+
+
 class NewInference(BaseModel):
     prompt: str
diff --git a/wavefront/server/modules/plugins_module/plugins_module/controllers/datasource_controller.py b/wavefront/server/modules/plugins_module/plugins_module/controllers/datasource_controller.py
index 93c9e97b..90ba74c4 100644
--- a/wavefront/server/modules/plugins_module/plugins_module/controllers/datasource_controller.py
+++ b/wavefront/server/modules/plugins_module/plugins_module/controllers/datasource_controller.py
@@ -24,6 +24,10 @@
 from db_repo_module.models.resource import ResourceScope
 from db_repo_module.models.datasource import Datasource
 from db_repo_module.repositories.sql_alchemy_repository import SQLAlchemyRepository
+from db_repo_module.cache.cache_manager import CacheManager
+from db_repo_module.cache.application_cache import (
+    invalidate_datasources_cache,
+)
 from datasource import DatasourcePlugin
 from datasource.types import DataSourceType, QueryResult, TableListResult
 from plugins_module.services.datasource_services import (
@@ -54,7 +58,6 @@
 from user_management_module.utils.user_utils import check_is_admin
 from user_management_module.utils.user_utils import get_current_user
 from plugins_module.services.dynamic_query_service import DynamicQueryService
-from db_repo_module.cache.cache_manager import CacheManager
 from ..utils.helper import (
     generate_cache_key,
     generate_export_filename_hash,
@@ -82,6 +85,7 @@ async def add_datasource(
     datasource_repository: SQLAlchemyRepository[Datasource] = Depends(
         Provide[PluginsContainer.datasource_repository]
     ),
+    cache_manager: CacheManager = Depends(Provide[PluginsContainer.cache_manager]),
 ):
     role_id = request.state.session.role_id
 
@@ -131,6 +135,7 @@ async def add_datasource(
         config=config_json,
         description=add_datasource_payload.description,
     )
+    invalidate_datasources_cache(cache_manager)
 
     return JSONResponse(
         status_code=status.HTTP_201_CREATED,
@@ -155,6 +160,7 @@ async def update_datasource(
     datasource_repository: SQLAlchemyRepository[Datasource] = Depends(
         Provide[PluginsContainer.datasource_repository]
     ),
+    cache_manager: CacheManager = Depends(Provide[PluginsContainer.cache_manager]),
 ):
     role_id = request.state.session.role_id
 
@@ -237,6 +243,7 @@ async def update_datasource(
     updated_datasource = await datasource_repository.find_one_and_update(
         filters={'id': datasource_id}, refresh=True, **update_data
     )
+    invalidate_datasources_cache(cache_manager)
 
     return JSONResponse(
         status_code=status.HTTP_200_OK,
@@ -261,6 +268,7 @@ async def delete_datasource(
     datasource_repository: SQLAlchemyRepository[Datasource] = Depends(
         Provide[PluginsContainer.datasource_repository]
     ),
+    cache_manager: CacheManager = Depends(Provide[PluginsContainer.cache_manager]),
 ):
     role_id = request.state.session.role_id
     is_admin = await check_is_admin(role_id)
@@ -285,6 +293,7 @@ async def delete_datasource(
 
     # Delete datasource
     await datasource_repository.delete_all(id=datasource_id)
+    invalidate_datasources_cache(cache_manager)
 
     return JSONResponse(
         status_code=status.HTTP_200_OK,