refactor application structure and enhance logging capabilities

- Introduced a new logging configuration for better traceability across components.
- Added a centralized logging setup in the config module.
- Implemented logging in various application components including agent, memory, and UI.
- Created new modules for knowledge base, tools, and visualizer functionalities.
- Updated .gitignore to include log files and added a new src directory for better organization.
- Removed deprecated memory management code and refactored conversation memory handling.
- Enhanced the Context Engineering Visualizer with improved context tracking and visualization features.

.gitignore

@@ -12,5 +12,9 @@ wheels/
 # Secrets
 .env
 
+# Log files
+logs/
+*.log
+
 # Reference files
 references/

config/__init__.py

@@ -1,5 +0,0 @@
-"""Configuration module for Context Engineering Visualizer"""
-
-from .settings import Settings
-
-__all__ = ["Settings"]

main.py

@@ -3,7 +3,18 @@ Context Engineering Visualizer
 Main entry point for the application
 """
 
+import sys
+import os
+
+# Add src directory to path
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), 'src'))
+
+from config import setup_logger
 from app.ui import launch_ui
 
+# Setup application logger - this initializes handlers
+logger = setup_logger("context_visualizer")
+
 if __name__ == "__main__":
+    logger.info("Starting Context Engineering Visualizer")
     launch_ui()

src/__init__.py

@@ -0,0 +1,3 @@
+"""Context Engineering Visualizer package"""
+
+__version__ = "1.0.0"

{app → src/app}/agent.py

@@ -7,7 +7,8 @@ from .visualizer import ContextVisualizer
 from .memory import ConversationMemory
 from .knowledge import KnowledgeBase
 from .tools import calculate_metric, get_current_time
-from config import Settings
+from config.settings import Settings
+from config import logger_agent, logger_memory, logger_knowledge
 
 
 class ContextEngineeringAgent:
@@ -20,12 +21,16 @@ class ContextEngineeringAgent:
     """
     
     def __init__(self):
+        logger_agent.info("Initializing ContextEngineeringAgent")
+        
         # Initialize components
+        logger_agent.debug(f"Initializing LLM with model: {Settings.MODEL_NAME}")
         self.llm = ChatOpenAI(
             model=Settings.MODEL_NAME,
             temperature=Settings.TEMPERATURE
         )
         
+        logger_agent.info("Loading knowledge base from FAISS index")
         self.knowledge_base = KnowledgeBase(
             pdf_path=Settings.PDF_PATH,
             index_path=Settings.FAISS_INDEX_PATH,
@@ -33,6 +38,8 @@ class ContextEngineeringAgent:
             top_k=Settings.RAG_TOP_K,
             recreate_index=False  # Load existing index by default
         )
+        
+        logger_agent.debug(f"Initializing conversation memory (max_messages={Settings.MAX_CONVERSATION_MESSAGES})")
         self.memory = ConversationMemory(max_messages=Settings.MAX_CONVERSATION_MESSAGES)
         self.visualizer = ContextVisualizer()
         
@@ -41,49 +48,64 @@ class ContextEngineeringAgent:
         
         # Create tools
         self.tools = [calculate_metric, get_current_time]
+        logger_agent.debug(f"Created {len(self.tools)} tools: {[t.name for t in self.tools]}")
         
         # Create agent
+        logger_agent.info("Creating LangChain agent with system prompt and tools")
         self.agent = create_agent(
             model=self.llm,
             tools=self.tools,
             system_prompt=self.system_prompt
         )
         
+        logger_agent.info("ContextEngineeringAgent initialized successfully")
+        
     def process_query(self, user_query: str) -> tuple[str, ContextVisualizer]:
         """
         Process a user query with full context engineering
         Returns: (response, visualizer)
         """
+        logger_agent.info(f"Processing query: {user_query[:50]}..." if len(user_query) > 50 else f"Processing query: {user_query}")
+        
         # Reset visualizer for new query
         self.visualizer = ContextVisualizer()
         
         # Layer 1: System Instructions
+        logger_agent.debug("Adding layer: System Instructions")
         self.visualizer.add_layer(
             "System Instructions",
             self.system_prompt,
         )
         
         # Layer 2: Conversation History
+        logger_memory.debug("Retrieving conversation history")
         history_text = self.memory.get_history_text()
+        logger_agent.debug(f"Conversation history length: {len(history_text)} characters")
         self.visualizer.add_layer(
             "Conversation History",
             history_text if history_text != "No previous conversation" else "No previous conversation",
         )
         
         # Layer 3: Retrieved Knowledge (RAG)
+        logger_knowledge.info(f"Retrieving relevant documents for query")
         retrieved_context = self.knowledge_base.retrieve_relevant(user_query)
+        doc_count = len([c for c in retrieved_context.split("--- Chunk") if c.strip()])
+        logger_knowledge.info(f"Retrieved {doc_count} document chunks")
+        logger_agent.debug(f"Retrieved context length: {len(retrieved_context)} characters")
         self.visualizer.add_layer(
             "Retrieved Knowledge (RAG)",
             retrieved_context,
         )
         
         # Layer 4: Current User Query
+        logger_agent.debug("Adding layer: User Query")
         self.visualizer.add_layer(
             "User Query",
             user_query,
         )
         
         # Layer 5: Available Tools
+        logger_agent.debug("Adding layer: Available Tools")
         tools_context = "\n".join([
             f"- {tool.name}: {tool.description}" for tool in self.tools
         ])
@@ -93,6 +115,9 @@ class ContextEngineeringAgent:
         )
         
         # Build the context structure
+        total_tokens = sum(self.visualizer.token_counts.values())
+        logger_agent.info(f"Total context size: {total_tokens} tokens across {len(self.visualizer.context_layers)} layers")
+        
         context_message = f"""Context from Knowledge Base:
 {retrieved_context}
 
@@ -103,15 +128,26 @@ Current Question:
 {user_query}"""
         
         # Invoke agent
-        result = self.agent.invoke({
-            "messages": [{"role": "user", "content": context_message}]
-        })
+        logger_agent.info("Invoking LangChain agent with assembled context")
+        try:
+            result = self.agent.invoke({
+                "messages": [{"role": "user", "content": context_message}]
+            })
+            logger_agent.info("Agent invocation successful")
+        except Exception as e:
+            logger_agent.error(f"Agent invocation failed: {str(e)}")
+            raise
         
         # Extract response
         response = result["messages"][-1].content
+        response_preview = response[:100] + "..." if len(response) > 100 else response
+        logger_agent.info(f"Generated response: {response_preview}")
         
         # Update conversation memory
+        logger_memory.info("Adding user message to conversation memory")
         self.memory.add_user_message(user_query)
+        logger_memory.info("Adding AI response to conversation memory")
         self.memory.add_ai_message(response)
         
+        logger_agent.info("Query processing completed successfully")
         return response, self.visualizer

{app → src/app}/knowledge.py

@@ -7,6 +7,7 @@ from langchain_community.vectorstores import FAISS
 from langchain_community.document_loaders import PyPDFLoader
 from langchain_text_splitters import RecursiveCharacterTextSplitter
 from langchain_core.documents import Document
+from config import logger_knowledge
 
 
 class KnowledgeBase:
@@ -26,6 +27,12 @@ class KnowledgeBase:
         self.pdf_path = pdf_path
         self.index_path = index_path
         self.top_k = top_k
+        
+        logger_knowledge.info(f"Initializing KnowledgeBase with embedding_model={embedding_model}, top_k={top_k}")
+        logger_knowledge.debug(f"PDF path: {pdf_path}")
+        logger_knowledge.debug(f"Index path: {index_path}")
+        
+        logger_knowledge.info(f"Loading OpenAI embeddings model: {embedding_model}")
         self.embeddings = OpenAIEmbeddings(model=embedding_model)
         self.vectorstore = self._load_or_create_index(recreate_index)
         
@@ -33,34 +40,48 @@ class KnowledgeBase:
         """Load existing FAISS index or create new one from PDF"""
         # If index exists and not recreating, load it
         if not recreate and os.path.exists(self.index_path):
-            print(f"Loading existing FAISS index from {self.index_path}")
-            return FAISS.load_local(
-                self.index_path,
-                self.embeddings,
-                allow_dangerous_deserialization=True
-            )
+            logger_knowledge.info(f"Loading existing FAISS index from {self.index_path}")
+            try:
+                vectorstore = FAISS.load_local(
+                    self.index_path,
+                    self.embeddings,
+                    allow_dangerous_deserialization=True
+                )
+                logger_knowledge.info("FAISS index loaded successfully")
+                return vectorstore
+            except Exception as e:
+                logger_knowledge.error(f"Failed to load FAISS index: {str(e)}")
+                raise
         
         # Otherwise, create new index
-        print(f"Creating new FAISS index from {self.pdf_path}")
+        logger_knowledge.info(f"Creating new FAISS index from {self.pdf_path}")
         
         # Remove old index if recreating
         if recreate and os.path.exists(self.index_path):
             import shutil
             try:
                 shutil.rmtree(self.index_path)
-                print("Removed old index directory")
+                logger_knowledge.info("Removed old index directory")
             except Exception as e:
-                print(f"Warning: Could not remove old index: {e}")
+                logger_knowledge.warning(f"Could not remove old index: {e}")
         
         # Load PDF document
         if not os.path.exists(self.pdf_path):
-            raise FileNotFoundError(f"PDF file not found: {self.pdf_path}")
+            error_msg = f"PDF file not found: {self.pdf_path}"
+            logger_knowledge.error(error_msg)
+            raise FileNotFoundError(error_msg)
         
-        loader = PyPDFLoader(self.pdf_path)
-        documents = loader.load()
-        print(f"Loaded {len(documents)} pages from PDF")
+        logger_knowledge.info(f"Loading PDF from {self.pdf_path}")
+        try:
+            loader = PyPDFLoader(self.pdf_path)
+            documents = loader.load()
+            logger_knowledge.info(f"Loaded {len(documents)} pages from PDF")
+        except Exception as e:
+            logger_knowledge.error(f"Failed to load PDF: {str(e)}")
+            raise
         
         # Split documents into chunks using RecursiveCharacterTextSplitter
+        logger_knowledge.info("Splitting documents into chunks")
         text_splitter = RecursiveCharacterTextSplitter(
             chunk_size=800,  # Optimized for better granularity
             chunk_overlap=150,  # Reduced proportionally
@@ -68,14 +89,24 @@ class KnowledgeBase:
             separators=["\n\n", "\n", ". ", ", ", " ", ""]  # Paragraph > Line > Sentence > Clause > Word
         )
         chunks = text_splitter.split_documents(documents)
-        print(f"Split into {len(chunks)} chunks")
+        logger_knowledge.info(f"Split into {len(chunks)} chunks")
         
         # Create FAISS index from chunks
-        vectorstore = FAISS.from_documents(chunks, self.embeddings)
+        logger_knowledge.info("Creating FAISS vector store from chunks")
+        try:
+            vectorstore = FAISS.from_documents(chunks, self.embeddings)
+            logger_knowledge.info("FAISS vector store created successfully")
+        except Exception as e:
+            logger_knowledge.error(f"Failed to create FAISS vector store: {str(e)}")
+            raise
         
         # Save the index
-        vectorstore.save_local(self.index_path)
-        print(f"Saved FAISS index to {self.index_path}")
+        try:
+            vectorstore.save_local(self.index_path)
+            logger_knowledge.info(f"Saved FAISS index to {self.index_path}")
+        except Exception as e:
+            logger_knowledge.error(f"Failed to save FAISS index: {str(e)}")
+            raise
         
         return vectorstore
     
@@ -91,11 +122,19 @@ class KnowledgeBase:
             List of relevant document chunks
         """
         if not self.vectorstore:
-            print("Warning: Vector store not initialized!")
+            logger_knowledge.error("Vector store not initialized!")
             return []
         
         k = k or self.top_k
-        return self.vectorstore.similarity_search(query, k=k)
+        logger_knowledge.debug(f"Retrieving top {k} documents for query")
+        
+        try:
+            results = self.vectorstore.similarity_search(query, k=k)
+            logger_knowledge.info(f"Retrieved {len(results)} documents")
+            return results
+        except Exception as e:
+            logger_knowledge.error(f"Document retrieval failed: {str(e)}")
+            raise
     
     def retrieve_relevant(self, query: str, k: int = None) -> str:
         """
@@ -108,8 +147,14 @@ class KnowledgeBase:
         Returns:
             Concatenated text from relevant documents with metadata
         """
+        logger_knowledge.info(f"Retrieving context for query: {query[:50]}..." if len(query) > 50 else f"Retrieving context for query: {query}")
+        
         docs = self.retrieve_relevant_docs(query, k)
         
+        if not docs:
+            logger_knowledge.warning("No documents retrieved for query")
+            return ""
+        
         formatted_chunks = []
         for i, doc in enumerate(docs, 1):
             chunk_text = f"--- Chunk {i} ---"
@@ -118,9 +163,15 @@ class KnowledgeBase:
             if doc.metadata:
                 metadata_str = ", ".join([f"{k}: {v}" for k, v in doc.metadata.items()])
                 chunk_text += f"\nMetadata: {metadata_str}"
+                logger_knowledge.debug(f"Chunk {i} metadata: {doc.metadata}")
             
             # Add content
+            content_preview = doc.page_content[:100] + "..." if len(doc.page_content) > 100 else doc.page_content
+            logger_knowledge.debug(f"Chunk {i} content preview: {content_preview}")
             chunk_text += f"\n\n{doc.page_content}"
             formatted_chunks.append(chunk_text)
         
+        total_length = sum(len(chunk) for chunk in formatted_chunks)
+        logger_knowledge.info(f"Formatted {len(formatted_chunks)} chunks, total length: {total_length} characters")
+        
         return "\n\n".join(formatted_chunks)

{app → src/app}/memory.py

@@ -2,6 +2,7 @@
 
 from typing import List
 from langchain.messages import HumanMessage, AIMessage
+from config import logger_memory
 
 
 class ConversationMemory:
@@ -10,33 +11,51 @@ class ConversationMemory:
     def __init__(self, max_messages: int = 4):
         self.messages = []
         self.max_messages = max_messages
+        logger_memory.info(f"ConversationMemory initialized with max_messages={max_messages}")
         
     def add_user_message(self, content: str):
         """Add user message to history"""
+        logger_memory.debug(f"Adding user message: {content[:50]}..." if len(content) > 50 else f"Adding user message: {content}")
         self.messages.append(HumanMessage(content=content))
+        current_count = len(self.messages)
+        logger_memory.info(f"User message added. Current message count: {current_count}")
         self._truncate()
         
     def add_ai_message(self, content: str):
         """Add AI message to history"""
+        content_preview = content[:50] + "..." if len(content) > 50 else content
+        logger_memory.debug(f"Adding AI message: {content_preview}")
         self.messages.append(AIMessage(content=content))
+        current_count = len(self.messages)
+        logger_memory.info(f"AI message added. Current message count: {current_count}")
         self._truncate()
         
     def _truncate(self):
         """Keep only recent messages to avoid context bloat"""
         if len(self.messages) > self.max_messages:
+            removed_count = len(self.messages) - self.max_messages
             self.messages = self.messages[-self.max_messages:]
+            logger_memory.info(f"Memory truncated: removed {removed_count} oldest messages, keeping {len(self.messages)} most recent")
+        else:
+            logger_memory.debug(f"No truncation needed. Current count: {len(self.messages)}, max: {self.max_messages}")
             
     def get_history(self) -> List:
         """Get formatted conversation history"""
-        return self.messages
+        history = self.messages
+        logger_memory.debug(f"Retrieving history: {len(history)} messages")
+        return history
     
     def get_history_text(self) -> str:
         """Get history as formatted text"""
         if not self.messages:
+            logger_memory.debug("No conversation history available")
             return "No previous conversation"
         
         history_text = []
         for msg in self.messages:
             role = "User" if isinstance(msg, HumanMessage) else "Assistant"
             history_text.append(f"{role}: {msg.content}")
-        return "\n".join(history_text)
+        
+        formatted = "\n".join(history_text)
+        logger_memory.debug(f"Formatted history: {len(formatted)} characters, {len(self.messages)} messages")
+        return formatted

{app → src/app}/tools.py

@@ -2,6 +2,7 @@
 
 from datetime import datetime
 from langchain.tools import tool
+from config import logger_app
 
 
 @tool
@@ -35,38 +36,54 @@ def calculate_metric(metric_name: str, values: str) -> str:
     Returns:
         A human-readable string containing the official computed metric.
     """
+    logger_app.info(f"Tool 'calculate_metric' invoked: metric={metric_name}, values={values}")
+    
     try:
         nums = [float(x.strip()) for x in values.split(",")]
+        logger_app.debug(f"Parsed values: {nums}")
 
         metric = metric_name.lower()
+        result = None
 
         if metric == "nrr":
             # Net Revenue Retention = retained revenue / starting revenue
             if len(nums) >= 2 and nums[1] != 0:
                 result = (nums[0] / nums[1]) * 100
-                return f"Net Revenue Retention (NRR): {result:.2f}%"
+                output = f"Net Revenue Retention (NRR): {result:.2f}%"
+                logger_app.info(f"Calculated NRR: {result:.2f}%")
+                return output
 
         elif metric == "stam":
             # Successful Transactions per Active Merchant
             if len(nums) >= 2 and nums[1] != 0:
                 result = nums[0] / nums[1]
-                return f"STAM: {result:.2f} successful transactions per merchant"
+                output = f"STAM: {result:.2f} successful transactions per merchant"
+                logger_app.info(f"Calculated STAM: {result:.2f}")
+                return output
 
         elif metric == "payment_success_rate":
             # Adjusted Payment Success Rate
             if len(nums) >= 2 and nums[1] != 0:
                 result = (nums[0] / nums[1]) * 100
-                return f"Payment Success Rate (Adjusted): {result:.2f}%"
+                output = f"Payment Success Rate (Adjusted): {result:.2f}%"
+                logger_app.info(f"Calculated Payment Success Rate: {result:.2f}%")
+                return output
 
-        return (
+        warning_msg = (
             f"Metric '{metric_name}' could not be computed. "
             "Please verify the metric name and input values."
         )
+        logger_app.warning(f"Failed to compute metric '{metric_name}' with values {nums}")
+        return warning_msg
 
     except Exception as e:
-        return f"Error computing metric '{metric_name}': {str(e)}"
+        error_msg = f"Error computing metric '{metric_name}': {str(e)}"
+        logger_app.error(error_msg)
+        return error_msg
 
 @tool
 def get_current_time() -> str:
     """Get the current date and time"""
-    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    logger_app.debug(f"Tool 'get_current_time' invoked: {current_time}")
+    return current_time

{app → src/app}/ui.py

@@ -4,7 +4,8 @@ import gradio as gr
 from typing import Tuple, List
 
 from .agent import ContextEngineeringAgent
-from config import Settings
+from config.settings import Settings
+from config import logger_ui, logger_app
 
 
 class ContextVisualizerUI:
@@ -13,13 +14,17 @@ class ContextVisualizerUI:
     def __init__(self):
         self.agent = None
         self.chat_history = []
+        logger_ui.info("ContextVisualizerUI initialized")
         
     def initialize_agent(self) -> str:
         """Initialize the agent"""
+        logger_ui.info("Initializing agent from UI")
         try:
             self.agent = ContextEngineeringAgent()
+            logger_ui.info("Agent initialized successfully from UI")
             return "Agent initialized successfully"
         except Exception as e:
+            logger_ui.error(f"Error initializing agent: {str(e)}")
             return f"Error initializing agent: {str(e)}"
     
     def format_context_layers(self, visualizer) -> str:
@@ -28,6 +33,7 @@ class ContextVisualizerUI:
             return "<div style='text-align: center; padding: 20px;'>No context layers available</div>"
         
         total_tokens = sum(visualizer.token_counts.values())
+        logger_ui.debug(f"Formatting context layers: {len(visualizer.context_layers)} layers, {total_tokens} total tokens")
         
         # Color palette for different layers
         colors = [
@@ -118,45 +124,60 @@ class ContextVisualizerUI:
     ) -> Tuple[List, str, str, str]:
         """Process user query and return results"""
         
+        logger_ui.info(f"Processing query from UI: {query[:50]}..." if len(query) > 50 else f"Processing query from UI: {query}")
+        
         if not self.agent:
+            logger_ui.info("Agent not initialized, initializing now")
             self.initialize_agent()
         
         if not query.strip():
+            logger_ui.warning("Empty query received, skipping")
             return history, "", "", ""
         
         try:
+            logger_ui.info("Delegating query processing to agent")
             # Process query
             response, visualizer = self.agent.process_query(query)
             
             # Add to chat history (format: list of dicts with role and content)
             history.append({"role": "user", "content": query})
             history.append({"role": "assistant", "content": response})
+            logger_ui.info(f"Added exchange to chat history. Total messages: {len(history)}")
             
             # Format outputs
             if show_visualization:
+                logger_ui.debug("Formatting context visualization")
                 context_viz_html = self.format_context_layers(visualizer)
                 context_details = self.format_context_details(visualizer)
             else:
+                logger_ui.debug("Visualization disabled by user")
                 context_viz_html = "<div style='text-align: center; padding: 20px; color: #7f8c8d;'>Visualization disabled</div>"
                 context_details = "Visualization disabled"
             
+            logger_ui.info("Query processed successfully")
             return history, "", context_viz_html, context_details
             
         except Exception as e:
             error_msg = f"Error processing query: {str(e)}"
+            logger_ui.error(error_msg)
             history.append({"role": "user", "content": query})
             history.append({"role": "assistant", "content": error_msg})
             return history, "", "", ""
     
     def clear_conversation(self) -> Tuple[List, str, str]:
         """Clear conversation history"""
+        logger_ui.info("Clearing conversation history")
         if self.agent:
+            previous_count = len(self.agent.memory.messages)
             self.agent.memory.messages = []
+            logger_ui.info(f"Cleared {previous_count} messages from conversation memory")
         return [], "", ""
     
     def create_interface(self) -> gr.Blocks:
         """Create the Gradio interface"""
         
+        logger_ui.info("Creating Gradio interface")
+        
         with gr.Blocks(
             title="Context Engineering Visualizer"
         ) as interface:
@@ -285,6 +306,7 @@ class ContextVisualizerUI:
             **Note**: This visualizer uses OpenAI's GPT model and requires an API key in your environment.
             """)
         
+        logger_ui.info("Gradio interface created successfully")
         return interface
 
 
@@ -294,6 +316,7 @@ def launch_ui(
     server_port: int = Settings.GRADIO_SERVER_PORT
 ):
     """Launch the Gradio interface"""
+    logger_app.info(f"Launching UI with settings: share={share}, server_name={server_name}, server_port={server_port}")
     ui = ContextVisualizerUI()
     interface = ui.create_interface()
     interface.launch(
@@ -302,3 +325,4 @@ def launch_ui(
         server_port=server_port,
         theme=gr.themes.Soft()
     )
+    logger_app.info("UI launched successfully")

src/config/__init__.py

@@ -0,0 +1,15 @@
+"""Configuration package for the Context Engineering Visualizer"""
+
+from .settings import Settings
+from .logging_config import setup_logger, get_logger, logger_agent, logger_ui, logger_knowledge, logger_memory, logger_app
+
+__all__ = [
+    "Settings",
+    "setup_logger",
+    "get_logger",
+    "logger_agent",
+    "logger_ui",
+    "logger_knowledge",
+    "logger_memory",
+    "logger_app",
+]

src/config/logging_config.py

@@ -0,0 +1,77 @@
+"""Centralized logging configuration for the Context Engineering Visualizer."""
+import logging
+import sys
+from pathlib import Path
+
+# Get project root (parent of src directory)
+PROJECT_ROOT = Path(__file__).parent.parent.parent
+
+# Default log file location - logs/app.log in project root
+DEFAULT_LOG_FILE = PROJECT_ROOT / 'logs' / 'app.log'
+
+
+def setup_logger(name: str = "context_visualizer", log_file: str = None, level: int = logging.INFO) -> logging.Logger:
+    """Setup centralized logging for the application.
+    
+    Args:
+        name: Logger name (default: "context_visualizer")
+        log_file: Optional log file path. If None, only console logging is enabled.
+                 Defaults to DEFAULT_LOG_FILE if not specified.
+        level: Logging level (default: logging.INFO)
+    
+    Returns:
+        Configured logger instance
+    """
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+    
+    # Remove existing handlers to avoid duplicates
+    logger.handlers.clear()
+    
+    # Console handler - prints to terminal
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(level)
+    console_formatter = logging.Formatter(
+        '%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        datefmt='%Y-%m-%d %H:%M:%S'
+    )
+    console_handler.setFormatter(console_formatter)
+    logger.addHandler(console_handler)
+    
+    # File handler - saves to logs/app.log
+    if log_file is not False:  # False means explicitly disable file logging
+        log_path = Path(log_file) if log_file else DEFAULT_LOG_FILE
+        log_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        file_handler = logging.FileHandler(log_path, encoding='utf-8')
+        file_handler.setLevel(logging.DEBUG)  # More detailed logging in file
+        file_formatter = logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(funcName)s:%(lineno)d - %(message)s',
+            datefmt='%Y-%m-%d %H:%M:%S'
+        )
+        file_handler.setFormatter(file_formatter)
+        logger.addHandler(file_handler)
+    
+    return logger
+
+
+def get_logger(name: str = None) -> logging.Logger:
+    """Get an existing logger or create a new one with default settings.
+    
+    Args:
+        name: Logger name. If None, returns the root 'context_visualizer' logger.
+    
+    Returns:
+        Logger instance
+    """
+    if name:
+        return logging.getLogger(f"context_visualizer.{name}")
+    return logging.getLogger("context_visualizer")
+
+
+# Pre-configured loggers for key components
+logger_agent = get_logger("agent")
+logger_ui = get_logger("ui")
+logger_knowledge = get_logger("knowledge")
+logger_memory = get_logger("memory")
+logger_app = get_logger("app")

{config → src/config}/settings.py

@@ -22,8 +22,8 @@ class Settings:
     RAG_TOP_K = 3
     
     # Vector Store Configuration
-    FAISS_INDEX_PATH = os.path.join(os.path.dirname(os.path.dirname(__file__)), "faiss_index_store")
-    PDF_PATH = os.path.join(os.path.dirname(os.path.dirname(__file__)), "data", "Product Strategy & Decision Handbook — Atlas Pay.pdf")
+    FAISS_INDEX_PATH = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), "faiss_index_store")
+    PDF_PATH = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), "data", "Product Strategy & Decision Handbook — Atlas Pay.pdf")
     
     # UI Settings
     GRADIO_SHARE = False

src/utils/__init__.py

@@ -0,0 +1 @@
+"""Utility scripts for Context Engineering Visualizer"""

{app → src/utils}/process_knowledge.py

@@ -3,7 +3,7 @@
 import sys
 import os
 
-# Add parent directory to path
+# Add parent directory to path (src/)
 sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
 
 from config.settings import Settings

uv.lock

@@ -453,12 +453,12 @@ dependencies = [
 [package.metadata]
 requires-dist = [
     { name = "faiss-cpu", specifier = ">=1.13.2" },
-    { name = "gradio", specifier = ">=6.3.0" },
+    { name = "gradio", specifier = ">=6.5.1" },
     { name = "ipykernel", specifier = ">=7.1.0" },
-    { name = "langchain", specifier = ">=1.2.6" },
+    { name = "langchain", specifier = ">=1.2.8" },
     { name = "langchain-community", specifier = ">=0.4.1" },
     { name = "langchain-openai", specifier = ">=1.1.7" },
-    { name = "pypdf", specifier = ">=6.6.0" },
+    { name = "pypdf", specifier = ">=6.6.2" },
     { name = "python-dotenv", specifier = ">=1.2.1" },
     { name = "tiktoken", specifier = ">=0.12.0" },
 ]