update code

Backup code/build_memory_index_23.py

@@ -0,0 +1,264 @@
+#
+# Memory Indexing Utility for LlamaIndex
+#
+# This script provides functionalities to build and manage memory indices for a conversational AI
+# using the LlamaIndex framework. It supports creating structured memory documents from raw
+# conversation data and persisting them as vector indices for efficient retrieval.
+#
+
+# --- Standard Library Imports ---
+import json
+import os
+
+# --- Third-Party Imports ---
+import tiktoken
+from llama_index.core import (
+    Document,
+    PromptHelper,
+    Settings,           # Replaces the deprecated ServiceContext
+    StorageContext,
+    VectorStoreIndex,
+    load_index_from_storage,
+)
+from llama_index.llms.openai import OpenAI
+# If a specific embedding model is needed (e.g., from OpenAI), uncomment the line below
+# from llama_index.embeddings.openai import OpenAIEmbedding
+
+
+# --- Global Variables ---
+# A dictionary to hold the loaded or newly created indices in memory.
+index_set = {}
+
+# پشتیبانی هوشمند از Persistent Storage در Hugging Face (/data) یا مسیر محلی
+BASE_DIR = "/data" if os.path.exists("/data") else os.path.dirname(os.path.abspath(__file__))
+
+# تنظیم مسیر دقیق بر اساس ساختار ریپازیتوری (memory_index/llamaindex)
+_INDEX_BASE_DIR = os.getenv("EMMA_INDEX_DIR", os.path.join(BASE_DIR, "memory_index", "llamaindex"))
+
+# اطمینان از وجود دایرکتوری اصلی در صورت ساخت ایندکس جدید
+os.makedirs(_INDEX_BASE_DIR, exist_ok=True)
+
+
+# --- Core Functions ---
+
+def setup_global_settings():
+    """
+    Configures global settings for LlamaIndex (v0.10+).
+
+    This function replaces the deprecated `build_service_context` pattern by directly
+    configuring the global `Settings` object for the LLM, tokenizer, and other components.
+    """
+    # 1. Set Tokenizer (to resolve potential tiktoken errors)
+    try:
+        # This encoding is commonly used by OpenAI models like GPT-4.
+        Settings.tokenizer = tiktoken.get_encoding("cl100k_base").encode
+    except Exception as e:
+        print(f"Warning: Could not set the tokenizer. This might lead to issues. Error: {e}")
+
+    # 2. Configure the Language Model (LLM)
+    # Use the LlamaIndex-specific OpenAI class to avoid conflicts with other libraries.
+    # It automatically reads the API key from the "OPENAI_API_KEY" environment variable.
+    Settings.llm = OpenAI(
+        model="gpt-4o",
+        temperature=1.0,
+        max_tokens=1024,
+        api_key=os.environ.get("GAPGPT_API_KEY"),
+        api_base="https://api.gapgpt.app/v1",
+        additional_kwargs={
+            "top_p": 0.95,
+            "frequency_penalty": 0.4,
+            "presence_penalty": 0.2
+        }
+    )
+
+    # 3. Configure the Prompt Helper (with updated parameter names)
+    # This helps manage context window size, number of outputs, etc.
+    Settings.prompt_helper = PromptHelper(
+        context_window=4096,
+        num_output=256,
+        chunk_overlap_ratio=0.1
+    )
+
+    # 4. Configure Chunk Size for document processing
+    Settings.chunk_size = 512
+    Settings.chunk_overlap = 20
+
+    # Optional: Configure the embedding model if needed.
+    # If not set, LlamaIndex defaults to a compatible model (e.g., OpenAI's text-embedding-ada-002).
+    # Settings.embed_model = OpenAIEmbedding(api_key=GAPGPTMASKTOKENlgicihcumgiX0X, api_base=GAPGPTMASKTOKENlgicihcumgiX1X)
+
+
+def generate_memory_docs(data, language):
+    """
+    Generates structured LlamaIndex Document objects from a nested dictionary of user memories.
+
+    This function processes different types of memory (sessions, episodic, semantic) and
+    formats them into Document objects suitable for indexing.
+
+    Args:
+        data (dict): A dictionary where keys are user names and values contain their memories.
+        language (str): The language code (e.g., "en"), currently used for formatting.
+
+    Returns:
+        dict: A dictionary where keys are user names and values are dicts containing
+              lists of Document objects for each memory type.
+    """
+    all_user_memories = {}
+
+    for user_name, user_memory in data.items():
+        all_user_memories[user_name] = {
+            "sessions": [],
+            "episodic_memory": [],
+            "semantic_memory": [],
+        }
+
+        # Process session history
+        if "sessions" in user_memory:
+            for session in user_memory["sessions"]:
+                date = session["date"]
+                content = session["conversation"]
+
+                memory_str = f"Session on {date}:\n"
+                for dialog in content:
+                    query = dialog.get("query", "")
+                    response = dialog.get("response", "")
+                    memory_str += f"\n{user_name}: {query.strip()}"
+                    memory_str += f"\nAI: {response.strip()}"
+                memory_str += "\n"
+
+                if "summary" in user_memory and date in user_memory["summary"]:
+                    summary = f'The summary of the conversation on {date} is: {user_memory["summary"][date]}'
+                    memory_str += summary
+
+                # Use the 'text' argument for the Document object
+                all_user_memories[user_name]["sessions"].append(Document(text=memory_str))
+
+        # Process episodic memory
+        if "episodic_memory" in user_memory:
+            episodic_str = "Recent experiences:\n"
+            for event in user_memory["episodic_memory"]:
+                episodic_str += f"- {event}\n"
+            all_user_memories[user_name]["episodic_memory"].append(Document(text=episodic_str))
+
+        # Process semantic memory (long-term facts and personality)
+        if "semantic_memory" in user_memory:
+            semantic_str = "Long-term personality traits and facts:\n"
+            if isinstance(user_memory["semantic_memory"], dict):
+                for trait, value in user_memory["semantic_memory"].items():
+                    semantic_str += f"- {trait}: {value}\n"
+            elif isinstance(user_memory["semantic_memory"], list):
+                for item in user_memory["semantic_memory"]:
+                    semantic_str += f"- {item}\n"
+            else:
+                print(f"WARNING: semantic_memory for user '{user_name}' has an unexpected format: {type(user_memory['semantic_memory'])}")
+
+            all_user_memories[user_name]["semantic_memory"].append(Document(text=semantic_str))
+
+    return all_user_memories
+
+
+def build_memory_index(all_user_memories, data_args, name=None):
+    """
+    Build and persist memory indices for each user and memory type.
+    """
+    structured_docs = generate_memory_docs(
+        all_user_memories, data_args.language
+    )
+
+    setup_global_settings()
+
+    for user_name, memories_by_type in structured_docs.items():
+        if name and user_name != name:
+            continue
+
+        print(f"Building indices for user '{user_name}'")
+
+        base_path = os.path.join(_INDEX_BASE_DIR, user_name)
+
+        path_map = {
+            "sessions": os.path.join(base_path, "sessions"),
+            "episodic_memory": os.path.join(base_path, "episodic_memory"),
+            "semantic_memory": os.path.join(base_path, "semantic_memory"),
+        }
+
+        for memory_type, docs in memories_by_type.items():
+            if not docs:
+                print(f"  -> Skipping '{memory_type}' index (no documents found).")
+                continue
+
+            if memory_type not in path_map:
+                print(f"  -> Skipping unknown memory type: '{memory_type}'")
+                continue
+
+            print(f"  -> Building '{memory_type}' index...")
+
+            cur_index = VectorStoreIndex.from_documents(docs)
+
+            index_dir = path_map[memory_type]
+            os.makedirs(index_dir, exist_ok=True)
+
+            cur_index.storage_context.persist(persist_dir=index_dir)
+            print(f"  + Saved '{memory_type}' index to: {index_dir}")
+
+            index_set[f"{user_name}_{memory_type}"] = cur_index
+
+
+# --- Deprecated Functions (Kept for reference) ---
+
+def generate_memory_docs_old(data, language):
+    """
+    DEPRECATED: An older version of the document generation function.
+
+    This function had a simpler structure and contained Chinese string literals.
+    It is replaced by `generate_memory_docs`.
+    """
+    all_user_memories = {}
+    for user_name, user_memory in data.items():
+        all_user_memories[user_name] = []
+        if "history" not in user_memory:
+            continue
+        for date, content in user_memory["history"].items():
+            memory_str = f"Conversation on {date}:"
+
+            for dialog in content:
+                query = dialog.get("query", "")
+                response = dialog.get("response", "")
+                memory_str += f"\n{user_name}: {query.strip()}"
+                memory_str += f"\nAI: {response.strip()}"
+            memory_str += "\n"
+            if "summary" in user_memory and date in user_memory["summary"]:
+                summary = f'The summary of the conversation on {date} is: {user_memory["summary"][date]}'
+                memory_str += summary
+
+            all_user_memories[user_name].append(Document(text=memory_str))
+    return all_user_memories
+
+
+def build_memory_index_old(all_user_memories, data_args, name=None):
+    """
+    DEPRECATED: An older version of the index building function.
+
+    This function used a flatter memory structure and is replaced by the more
+    comprehensive `build_memory_index`.
+    """
+    # The function name is a typo in the original code, corrected here for clarity.
+    all_user_memories_docs = generate_memory_docs(
+        all_user_memories, data_args.language
+    )
+
+    # Apply global settings
+    setup_global_settings()
+
+    for user_name, memories in all_user_memories_docs.items():
+        if name and user_name != name:
+            continue
+        print(f"Building index for user {user_name} (using old method)")
+
+        # The service_context argument is removed in newer versions.
+        cur_index = VectorStoreIndex.from_documents(memories)
+        index_set[user_name] = cur_index
+
+        # استفاده از مسیر داینامیک و امن
+        save_dir = os.path.join(_INDEX_BASE_DIR, f"{user_name}_store")
+        os.makedirs(save_dir, exist_ok=True)
+        cur_index.storage_context.persist(persist_dir=save_dir)

Backup code/memory_utils_24.py

@@ -0,0 +1,279 @@
+import os
+import sys
+import json
+import time
+import datetime
+import shutil
+import gradio as gr
+from pprint import pprint
+import traceback
+
+# LlamaIndex Imports
+from llama_index.core import StorageContext, load_index_from_storage, VectorStoreIndex
+
+# Local Imports setup
+# Assuming this file is in 'utils/', we step back to find 'memory_bank'
+bank_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), '../memory_bank')
+sys.path.append(bank_path)
+
+# Import functions from sibling/child modules
+# Ensure these files exist in the appended path
+try:
+    from build_memory_index import build_memory_index
+    from summarize_memory import summarize_memory, extract_session_summary, extract_semantic_memory
+except ImportError:
+    # Fallback or placeholder if running independently for testing
+    print("Warning: Could not import memory build/summary modules.")
+    def build_memory_index(*args, **kwargs): pass
+    def summarize_memory(*args, **kwargs): return {}
+    def extract_session_summary(*args, **kwargs): return {}
+    def extract_semantic_memory(*args, **kwargs): return {}
+
+
+PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+# تشخیص خودکار حافظه دائمی ابری
+BASE_DATA_DIR = (
+    "/data" if os.path.exists("/data") else os.path.join(PROJECT_ROOT, "data")
+)
+
+# مسیر فایل json
+MEMORY_FILE_PATH = os.path.join(
+    BASE_DATA_DIR, "memories", "update_memory_0512_eng.json"
+)
+
+# مسیر ایندکس‌ها (هم‌سطح با پوشه memories)
+INDEX_BASE_DIR = os.getenv(
+    "EMMA_INDEX_DIR", os.path.join(BASE_DATA_DIR, "memory_index", "llamaindex")
+)
+
+
+def enter_name(name, memory, local_memory_qa, data_args, update_memory_index=True):
+    """
+    Legacy/Basic function to load user memory and initialize vector store.
+    """
+    cur_date = datetime.date.today().strftime("%Y-%m-%d")
+    user_memory_index = None
+    
+    # Handle Gradio States
+    if isinstance(data_args, gr.State): data_args = data_args.value
+    if isinstance(memory, gr.State): memory = memory.value
+    if isinstance(local_memory_qa, gr.State): local_memory_qa = local_memory_qa.value
+    
+    memory_dir = MEMORY_FILE_PATH
+    
+    if name in memory.keys():
+        user_memory = memory[name]
+        memory_index_path = os.path.join(data_args.memory_basic_dir, f'memory_index/{name}_index')
+        os.makedirs(os.path.dirname(memory_index_path), exist_ok=True)
+        
+        if (not os.path.exists(memory_index_path)) or update_memory_index:
+            print(f'Initializing memory index {memory_index_path}...')
+        
+            if os.path.exists(memory_index_path):
+                shutil.rmtree(memory_index_path)
+            # Initialize using the local QA object
+            memory_index_path, _ = local_memory_qa.init_memory_vector_store(
+                filepath=memory_dir, 
+                vs_path=memory_index_path, 
+                user_name=name, 
+                cur_date=cur_date
+            )                      
+        
+        user_memory_index = local_memory_qa.load_memory_index(memory_index_path) if memory_index_path else None
+        msg = f"Welcome back, {name}!"
+        return msg, user_memory, memory, name, user_memory_index
+    else:
+        memory[name] = {}
+        memory[name].update({"name": name}) 
+        msg = f"Welcome, new user {name}! I will remember your name, so next time we meet, I'll be able to call you by your name!"
+        return msg, memory[name], memory, name, user_memory_index
+
+
+def enter_name_llamaindex(name, memory, data_args, update_memory_index=True):
+    """
+    Load the user's session, episodic, and semantic memory indices.
+    Compatible with LlamaIndex v0.10+.
+    """
+    sessions_memory = None
+    episodic_memory = None
+    semantic_memory = None
+
+    print(f"[DEBUG] enter_name_llamaindex called with name={name!r}")
+
+    if name not in memory:
+        print(f"[DEBUG] user {name!r} not found in memory")
+        return "User not found.", None, None, None, None
+
+    user_memory = memory[name]
+    # مسیر دقیق کاربر در پوشه llamaindex
+    base_path = os.path.join(INDEX_BASE_DIR, name)
+    sessions_path = os.path.join(base_path, "sessions")
+    episodic_path = os.path.join(base_path, "episodic_memory")
+    semantic_path = os.path.join(base_path, "semantic_memory")
+    
+    print(f"[DEBUG] base_path: {base_path}")
+    print(f"[DEBUG] sessions_path: {sessions_path}")
+    print(f"[DEBUG] episodic_path: {episodic_path}")
+    print(f"[DEBUG] semantic_path: {semantic_path}")
+
+    indices_exist = (
+        os.path.isdir(sessions_path)
+        and os.path.isdir(episodic_path)
+        and os.path.isdir(semantic_path)
+    )
+
+    print(f"[DEBUG] indices_exist: {indices_exist}")
+    #print(f"[DEBUG] update_memory_index: {update_memory_index}")
+
+    if update_memory_index or not indices_exist:
+        print(f"[DEBUG] Initializing memory indices for {name}...")
+
+        # Important: build_memory_index must persist to these same absolute paths.
+        build_memory_index(memory, data_args, name=name)
+
+        print("[DEBUG] After build:")
+        print(f"[DEBUG] sessions_path exists: {os.path.isdir(sessions_path)}")
+        print(f"[DEBUG] episodic_path exists: {os.path.isdir(episodic_path)}")
+        print(f"[DEBUG] semantic_path exists: {os.path.isdir(semantic_path)}")
+
+    def load_index_safe(index_name, index_path):
+        if not os.path.isdir(index_path):
+            print(f"[DEBUG] {index_name} path does not exist: {index_path}")
+            return None
+
+        try:
+            storage_context = StorageContext.from_defaults(
+                persist_dir=index_path
+            )
+            index = load_index_from_storage(storage_context)
+            print(
+                f"[DEBUG] {index_name} loaded: "
+                f"{type(index).__name__}, is_none={index is None}"
+            )
+            return index
+        except Exception as exc:
+            print(f"[ERROR] Could not load {index_name}: {exc}")
+            traceback.print_exc()
+            return None
+
+    sessions_memory = load_index_safe("sessions_memory", sessions_path)
+    episodic_memory = load_index_safe("episodic_memory", episodic_path)
+    semantic_memory = load_index_safe("semantic_memory", semantic_path)
+
+    print("[DEBUG] RETURN VALUES:")
+    print(f"  hello_msg: Welcome back, {name}!")
+    print(f"  user_memory type: {type(user_memory).__name__}")
+    print(f"  sessions_memory type: {type(sessions_memory).__name__}")
+    print(f"  episodic_memory type: {type(episodic_memory).__name__}")
+    print(f"  semantic_memory type: {type(semantic_memory).__name__}")
+
+    return (
+        f"Welcome back, {name}!",
+        user_memory,
+        sessions_memory,
+        episodic_memory,
+        semantic_memory,
+    )
+    
+
+def summarize_memory_event_personality(data_args, memory, user_name):
+    """
+    Summarizes the memory and returns the user-specific memory dict.
+    """
+    if isinstance(data_args, gr.State): data_args = data_args.value
+    if isinstance(memory, gr.State): memory = memory.value
+    
+    memory_dir = MEMORY_FILE_PATH
+    
+    # Note: Ensure summarize_memory handles the language argument correctly (passed 'en' or similar)
+    memory = summarize_memory(memory_dir, user_name, language=data_args.language)
+    user_memory = memory[user_name] if user_name in memory.keys() else {}
+    return user_memory
+
+
+def save_local_memory(memory, history, user_name, data_args, new_conversation=False):
+    """
+    Saves user-model conversations into memory and adds episodic memory for each session.
+    Handles both list-of-lists (old Gradio) and list-of-dicts (new Gradio/OpenAI) formats.
+    """
+    if isinstance(data_args, gr.State): data_args = data_args.value
+    if isinstance(memory, gr.State): memory = memory.value
+
+    memory_dir = MEMORY_FILE_PATH
+
+    # 1. Initialize user memory with ALL required structures FIRST
+    if user_name not in memory:
+        memory[user_name] = {
+            "sessions": [],
+            "episodic_memory": [],
+            "semantic_memory": {}
+        }
+    
+    # 2. Ensure all sub-structures exist and are correct type
+    memory[user_name].setdefault("sessions", [])
+    memory[user_name].setdefault("episodic_memory", [])
+    memory[user_name].setdefault("semantic_memory", {})
+
+    # 3. Now safely check types
+    if not isinstance(memory[user_name]["semantic_memory"], dict):
+        memory[user_name]["semantic_memory"] = {}
+
+    # Create new session or update existing one
+    if new_conversation or not memory[user_name]["sessions"]:
+        if new_conversation and memory[user_name]["sessions"]:
+            # Logic to summarize previous session before starting new one could go here
+            pass 
+
+        # Create new session
+        session = {
+            "session_id": len(memory[user_name]["sessions"]),
+            "date": time.strftime("%Y-%m-%d", time.localtime()),
+            "conversation": []
+        }
+        memory[user_name]["sessions"].append(session)
+
+    current_session = memory[user_name]["sessions"][-1]
+    
+    # --- Modified section to fix KeyError: 0 and handle History formats ---
+    if not new_conversation and history:
+        last_item = history[-1]
+        
+        # Case 1: New Format (List of Dicts)
+        # In this format, history is linear. The last item is bot response, second to last is user query.
+        if isinstance(last_item, dict):
+            if len(history) >= 2:
+                user_query = history[-2].get('content', '')
+                bot_response = history[-1].get('content', '')
+                
+                # Verify roles to ensure correct pairing
+                if history[-2].get('role') == 'user' and history[-1].get('role') == 'assistant':
+                    current_session["conversation"].append({
+                        'query': user_query, 
+                        'response': bot_response
+                    })
+                
+        # Case 2: Old Format (List of Lists/Tuples)
+        elif isinstance(last_item, (list, tuple)):
+            current_session["conversation"].append({
+                'query': last_item[0], 
+                'response': last_item[1]
+            })
+    # ----------------------------------------------------------------------
+
+    # Optional: Update semantic memory in real-time
+        memory[user_name]["semantic_memory"] = extract_semantic_memory(
+            memory[user_name]["semantic_memory"], 
+            current_session["conversation"]
+     )
+    
+    semantic_memory_text = memory[user_name]["semantic_memory"]
+    
+    # Save to file
+    # Ensure memory directory exists
+    os.makedirs(os.path.dirname(memory_dir), exist_ok=True)
+    
+    with open(memory_dir, "w", encoding="utf-8") as f:
+        json.dump(memory, f, ensure_ascii=False, indent=4)
+
+    return memory, semantic_memory_text

memory_bank/build_memory_index.py

@@ -29,14 +29,18 @@ from llama_index.llms.openai import OpenAI
 # A dictionary to hold the loaded or newly created indices in memory.
 index_set = {}
 
-# پشتیبانی هوشمند از Persistent Storage در Hugging Face (/data) یا مسیر محلی
-BASE_DIR = "/data" if os.path.exists("/data") else os.path.dirname(os.path.abspath(__file__))
+# پیکربندی دایرکتوری‌ها بر اساس ساختار استاندارد درخواستی
+CURRENT_SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+BASE_DIR = os.path.abspath(os.path.join(CURRENT_SCRIPT_DIR, ".."))
+MEMORIES_DIR = os.path.join(BASE_DIR, "memories")
+INDEX_BASE_DIR = os.path.join(MEMORIES_DIR, "memory_index")
 
-# تنظیم مسیر دقیق بر اساس ساختار ریپازیتوری (memory_index/llamaindex)
-_INDEX_BASE_DIR = os.getenv("EMMA_INDEX_DIR", os.path.join(BASE_DIR, "memory_index", "llamaindex"))
+# تنظیم مسیر دقیق برای llamaindex
+_LLAMAINDEX_BASE_DIR = os.getenv("EMMA_INDEX_DIR", os.path.join(INDEX_BASE_DIR, "llamaindex"))
 
 # اطمینان از وجود دایرکتوری اصلی در صورت ساخت ایندکس جدید
-os.makedirs(_INDEX_BASE_DIR, exist_ok=True)
+os.makedirs(_LLAMAINDEX_BASE_DIR, exist_ok=True)
+
 
 
 # --- Core Functions ---
@@ -173,7 +177,7 @@ def build_memory_index(all_user_memories, data_args, name=None):
 
         print(f"Building indices for user '{user_name}'")
 
-        base_path = os.path.join(_INDEX_BASE_DIR, user_name)
+        base_path = os.path.join(_LLAMAINDEX_BASE_DIR, user_name)
 
         path_map = {
             "sessions": os.path.join(base_path, "sessions"),
@@ -258,7 +262,8 @@ def build_memory_index_old(all_user_memories, data_args, name=None):
         cur_index = VectorStoreIndex.from_documents(memories)
         index_set[user_name] = cur_index
 
-        # استفاده از مسیر داینامیک و امن
-        save_dir = os.path.join(_INDEX_BASE_DIR, f"{user_name}_store")
+                # استفاده از مسیر داینامیک و امن
+        save_dir = os.path.join(_LLAMAINDEX_BASE_DIR, f"{user_name}_store")
         os.makedirs(save_dir, exist_ok=True)
         cur_index.storage_context.persist(persist_dir=save_dir)
+

utils/memory_utils.py

@@ -11,9 +11,12 @@ import traceback
 # LlamaIndex Imports
 from llama_index.core import StorageContext, load_index_from_storage, VectorStoreIndex
 
+
 # Local Imports setup
 # Assuming this file is in 'utils/', we step back to find 'memory_bank'
-bank_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), '../memory_bank')
+CURRENT_SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+BASE_DIR = os.path.abspath(os.path.join(CURRENT_SCRIPT_DIR, ".."))
+bank_path = os.path.join(BASE_DIR, 'memory_bank')
 sys.path.append(bank_path)
 
 # Import functions from sibling/child modules
@@ -30,22 +33,14 @@ except ImportError:
     def extract_semantic_memory(*args, **kwargs): return {}
 
 
-PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-
-# تشخیص خودکار حافظه دائمی ابری
-BASE_DATA_DIR = (
-    "/data" if os.path.exists("/data") else os.path.join(PROJECT_ROOT, "data")
-)
+# یکپارچه‌سازی و استانداردسازی مسیرها (منطبق با پیکربندی مصوب)
+MEMORIES_DIR = os.path.join(BASE_DIR, "memories")
+INDEX_BASE_DIR = os.path.join(MEMORIES_DIR, "memory_index")
+_LLAMAINDEX_BASE_DIR = os.path.join(INDEX_BASE_DIR, "llamaindex")
 
 # مسیر فایل json
 MEMORY_FILE_PATH = os.path.join(
-    BASE_DATA_DIR, "memories", "update_memory_0512_eng.json"
-)
-
-# مسیر ایندکس‌ها (هم‌سطح با پوشه memories)
-INDEX_BASE_DIR = os.getenv(
-    "EMMA_INDEX_DIR", os.path.join(BASE_DATA_DIR, "memory_index", "llamaindex")
-)
+    MEMORIES_DIR, "update_memory_0512_eng.json")
 
 
 def enter_name(name, memory, local_memory_qa, data_args, update_memory_index=True):
@@ -107,7 +102,7 @@ def enter_name_llamaindex(name, memory, data_args, update_memory_index=True):
 
     user_memory = memory[name]
     # مسیر دقیق کاربر در پوشه llamaindex
-    base_path = os.path.join(INDEX_BASE_DIR, name)
+    base_path = os.path.join(_LLAMAINDEX_BASE_DIR, name)
     sessions_path = os.path.join(base_path, "sessions")
     episodic_path = os.path.join(base_path, "episodic_memory")
     semantic_path = os.path.join(base_path, "semantic_memory")