Remove unwanted logs and print statements

api/api.py

@@ -207,7 +207,7 @@ async def get_model_config():
         ModelConfig: A configuration object containing providers and their models
     """
     try:
-        logger.info("Fetching model configurations")
+        # Fetching model configurations
 
         # Create providers from the config file
         providers = []
@@ -267,7 +267,7 @@ async def export_wiki(request: WikiExportRequest):
         A downloadable file in the requested format
     """
     try:
-        logger.info(f"Exporting wiki for {request.repo_url} in {request.format} format")
+        print(f"Exporting wiki for {request.repo_url} in {request.format} format")
 
         # Extract repository name from URL for the filename
         repo_parts = request.repo_url.rstrip('/').split('/')
@@ -319,7 +319,7 @@ async def get_local_repo_structure(path: str = Query(None, description="Path to
         )
 
     try:
-        logger.info(f"Processing local repository at: {path}")
+        print(f"Processing local repository at: {path}")
         file_tree_lines = []
         readme_content = ""
 
@@ -338,7 +338,7 @@ async def get_local_repo_structure(path: str = Query(None, description="Path to
                         with open(os.path.join(root, file), 'r', encoding='utf-8') as f:
                             readme_content = f.read()
                     except Exception as e:
-                        logger.warning(f"Could not read README.md: {str(e)}")
+                        print(f"Warning: Could not read README.md: {str(e)}")
                         readme_content = ""
 
         file_tree_str = '\n'.join(sorted(file_tree_lines))
@@ -459,7 +459,7 @@ async def read_wiki_cache(owner: str, repo: str, repo_type: str, language: str)
 async def save_wiki_cache(data: WikiCacheRequest) -> bool:
     """Saves wiki cache data to the file system."""
     cache_path = get_wiki_cache_path(data.repo.owner, data.repo.repo, data.repo.type, data.language)
-    logger.info(f"Attempting to save wiki cache. Path: {cache_path}")
+    # Saving to cache
     try:
         payload = WikiCacheData(
             wiki_structure=data.wiki_structure,
@@ -468,19 +468,13 @@ async def save_wiki_cache(data: WikiCacheRequest) -> bool:
             provider=data.provider,
             model=data.model
         )
-        # Log size of data to be cached for debugging (avoid logging full content if large)
-        try:
-            payload_json = payload.model_dump_json()
-            payload_size = len(payload_json.encode('utf-8'))
-            logger.info(f"Payload prepared for caching. Size: {payload_size} bytes.")
-        except Exception as ser_e:
-            logger.warning(f"Could not serialize payload for size logging: {ser_e}")
+        # Payload prepared for caching
 
 
-        logger.info(f"Writing cache file to: {cache_path}")
+        # Writing cache file
         with open(cache_path, 'w', encoding='utf-8') as f:
             json.dump(payload.model_dump(), f, indent=2)
-        logger.info(f"Wiki cache successfully saved to {cache_path}")
+        print(f"Wiki cache saved to {cache_path}")
         return True
     except IOError as e:
         logger.error(f"IOError saving wiki cache to {cache_path}: {e.strerror} (errno: {e.errno})", exc_info=True)
@@ -506,14 +500,14 @@ async def get_cached_wiki(
     if not supported_langs.__contains__(language):
         language = configs["lang_config"]["default"]
 
-    logger.info(f"Attempting to retrieve wiki cache for {owner}/{repo} ({repo_type}), lang: {language}")
+        # Retrieving wiki cache
     cached_data = await read_wiki_cache(owner, repo, repo_type, language)
     if cached_data:
         return cached_data
     else:
         # Return 200 with null body if not found, as frontend expects this behavior
         # Or, raise HTTPException(status_code=404, detail="Wiki cache not found") if preferred
-        logger.info(f"Wiki cache not found for {owner}/{repo} ({repo_type}), lang: {language}")
+        # Wiki cache not found
         return None
 
 @app.post("/api/wiki_cache")
@@ -527,7 +521,7 @@ async def store_wiki_cache(request_data: WikiCacheRequest):
     if not supported_langs.__contains__(request_data.language):
         request_data.language = configs["lang_config"]["default"]
 
-    logger.info(f"Attempting to save wiki cache for {request_data.repo.owner}/{request_data.repo.repo} ({request_data.repo.type}), lang: {request_data.language}")
+    print(f"Saving wiki cache for {request_data.repo.owner}/{request_data.repo.repo}")
     success = await save_wiki_cache(request_data)
     if success:
         return {"message": "Wiki cache saved successfully"}
@@ -551,23 +545,23 @@ async def delete_wiki_cache(
         raise HTTPException(status_code=400, detail="Language is not supported")
 
     if WIKI_AUTH_MODE:
-        logger.info("check the authorization code")
+        # Checking authorization code
         if WIKI_AUTH_CODE != authorization_code:
             raise HTTPException(status_code=401, detail="Authorization code is invalid")
 
-    logger.info(f"Attempting to delete wiki cache for {owner}/{repo} ({repo_type}), lang: {language}")
+    print(f"Deleting wiki cache for {owner}/{repo}")
     cache_path = get_wiki_cache_path(owner, repo, repo_type, language)
 
     if os.path.exists(cache_path):
         try:
             os.remove(cache_path)
-            logger.info(f"Successfully deleted wiki cache: {cache_path}")
+            print(f"Successfully deleted wiki cache: {cache_path}")
             return {"message": f"Wiki cache for {owner}/{repo} ({language}) deleted successfully"}
         except Exception as e:
             logger.error(f"Error deleting wiki cache {cache_path}: {e}")
             raise HTTPException(status_code=500, detail=f"Failed to delete wiki cache: {str(e)}")
     else:
-        logger.warning(f"Wiki cache not found, cannot delete: {cache_path}")
+        print(f"Warning: Wiki cache not found: {cache_path}")
         raise HTTPException(status_code=404, detail="Wiki cache not found")
 
 @app.get("/health")
@@ -618,10 +612,10 @@ async def get_processed_projects():
 
     try:
         if not os.path.exists(WIKI_CACHE_DIR):
-            logger.info(f"Cache directory {WIKI_CACHE_DIR} not found. Returning empty list.")
+            print(f"Cache directory {WIKI_CACHE_DIR} not found")
             return []
 
-        logger.info(f"Scanning for project cache files in: {WIKI_CACHE_DIR}")
+        # Scanning for project cache files
         filenames = await asyncio.to_thread(os.listdir, WIKI_CACHE_DIR) # Use asyncio.to_thread for os.listdir
 
         for filename in filenames:
@@ -652,14 +646,14 @@ async def get_processed_projects():
                             )
                         )
                     else:
-                        logger.warning(f"Could not parse project details from filename: {filename}")
+                        print(f"Warning: Could not parse project details from filename: {filename}")
                 except Exception as e:
                     logger.error(f"Error processing file {file_path}: {e}")
                     continue # Skip this file on error
 
         # Sort by most recent first
         project_entries.sort(key=lambda p: p.submittedAt, reverse=True)
-        logger.info(f"Found {len(project_entries)} processed project entries.")
+        print(f"Found {len(project_entries)} processed project entries")
         return project_entries
 
     except Exception as e:

api/config.py

@@ -97,10 +97,7 @@ def replace_env_placeholders(config: Union[Dict[str, Any], List[Any], str, Any])
         original_placeholder = match.group(0)
         env_var_value = os.environ.get(env_var_name)
         if env_var_value is None:
-            logger.warning(
-                f"Environment variable placeholder '{original_placeholder}' was not found in the environment. "
-                f"The placeholder string will be used as is."
-            )
+            # Environment variable placeholder not found, using as is
             return original_placeholder
         return env_var_value
 
@@ -124,10 +121,10 @@ def load_json_config(filename):
             # Otherwise use default directory
             config_path = Path(__file__).parent / "config" / filename
 
-        logger.info(f"Loading configuration from {config_path}")
+        # Loading configuration
 
         if not config_path.exists():
-            logger.warning(f"Configuration file {config_path} does not exist")
+            print(f"Warning: Configuration file {config_path} does not exist")
             return {}
 
         with open(config_path, 'r', encoding='utf-8') as f:
@@ -135,7 +132,7 @@ def load_json_config(filename):
             config = replace_env_placeholders(config)
             return config
     except Exception as e:
-        logger.error(f"Error loading configuration file {filename}: {str(e)}")
+        print(f"Error loading configuration file {filename}: {str(e)}")
         return {}
 
 # Load generator model configuration
@@ -161,7 +158,7 @@ def load_generator_config():
                 }
                 provider_config["model_client"] = default_map[provider_id]
             else:
-                logger.warning(f"Unknown provider or client class: {provider_id}")
+                print(f"Warning: Unknown provider or client class: {provider_id}")
 
     return generator_config
 
@@ -235,7 +232,7 @@ def load_lang_config():
         return default_config
 
     if "supported_languages" not in loaded_config or "default" not in loaded_config:
-        logger.warning("Language configuration file 'lang.json' is malformed. Using default language configuration.")
+        print("Warning: Language configuration file 'lang.json' is malformed")
         return default_config
 
     return loaded_config

api/data_pipeline.py

@@ -51,7 +51,7 @@ def count_tokens(text: str, is_ollama_embedder: bool = None) -> int:
         return len(encoding.encode(text))
     except Exception as e:
         # Fallback to a simple approximation if tiktoken fails
-        logger.warning(f"Error counting tokens with tiktoken: {e}")
+        print(f"Warning: Error counting tokens with tiktoken: {e}")
         # Rough approximation: 4 characters per token
         return len(text) // 4
 
@@ -69,7 +69,7 @@ def download_repo(repo_url: str, local_path: str, type: str = "github", access_t
     """
     try:
         # Check if Git is installed
-        logger.info(f"Preparing to clone repository to {local_path}")
+        print(f"Preparing to clone repository to {local_path}")
         subprocess.run(
             ["git", "--version"],
             check=True,
@@ -80,7 +80,7 @@ def download_repo(repo_url: str, local_path: str, type: str = "github", access_t
         # Check if repository already exists
         if os.path.exists(local_path) and os.listdir(local_path):
             # Directory exists and is not empty
-            logger.warning(f"Repository already exists at {local_path}. Using existing repository.")
+            print(f"Repository already exists at {local_path}")
             return f"Using existing repository at {local_path}"
 
         # Ensure the local path exists
@@ -102,10 +102,10 @@ def download_repo(repo_url: str, local_path: str, type: str = "github", access_t
                 # Format: https://x-token-auth:{token}@bitbucket.org/owner/repo.git
                 clone_url = urlunparse((parsed.scheme, f"x-token-auth:{access_token}@{parsed.netloc}", parsed.path, '', '', ''))
 
-            logger.info("Using access token for authentication")
+            # Using access token for authentication
 
         # Clone the repository
-        logger.info(f"Cloning repository from {repo_url} to {local_path}")
+        print(f"Cloning repository from {repo_url}")
         # We use repo_url in the log to avoid exposing the token in logs
         result = subprocess.run(
             ["git", "clone", "--depth=1", "--single-branch", clone_url, local_path],
@@ -114,7 +114,7 @@ def download_repo(repo_url: str, local_path: str, type: str = "github", access_t
             stderr=subprocess.PIPE,
         )
 
-        logger.info("Repository cloned successfully")
+        print("Repository cloned successfully")
         return result.stdout.decode("utf-8")
 
     except subprocess.CalledProcessError as e:
@@ -164,9 +164,7 @@ def read_all_documents(path: str, is_ollama_embedder: bool = None, excluded_dirs
         final_included_dirs = set(included_dirs) if included_dirs else set()
         final_included_files = set(included_files) if included_files else set()
 
-        logger.info(f"Using inclusion mode")
-        logger.info(f"Included directories: {list(final_included_dirs)}")
-        logger.info(f"Included files: {list(final_included_files)}")
+        print(f"Using inclusion mode: dirs={list(final_included_dirs)}, files={list(final_included_files)}")
 
         # Convert to lists for processing
         included_dirs = list(final_included_dirs)
@@ -199,11 +197,9 @@ def read_all_documents(path: str, is_ollama_embedder: bool = None, excluded_dirs
         included_dirs = []
         included_files = []
 
-        logger.info(f"Using exclusion mode")
-        logger.info(f"Excluded directories: {excluded_dirs}")
-        logger.info(f"Excluded files: {excluded_files}")
+        # Using exclusion mode with default filters
 
-    logger.info(f"Reading documents from {path}")
+    print(f"Reading documents from {path}")
 
     def should_process_file(file_path: str, use_inclusion: bool, included_dirs: List[str], included_files: List[str],
                            excluded_dirs: List[str], excluded_files: List[str]) -> bool:
@@ -323,7 +319,7 @@ def read_all_documents(path: str, is_ollama_embedder: bool = None, excluded_dirs
                     # Check token count
                     token_count = count_tokens(content, is_ollama_embedder)
                     if token_count > MAX_EMBEDDING_TOKENS * 10:
-                        logger.warning(f"Skipping large file {relative_path}: Token count ({token_count}) exceeds limit")
+                        print(f"Skipping large file {relative_path}: {token_count} tokens")
                         continue
 
                     doc = Document(
@@ -339,7 +335,7 @@ def read_all_documents(path: str, is_ollama_embedder: bool = None, excluded_dirs
                     )
                     documents.append(doc)
             except Exception as e:
-                logger.error(f"Error reading {file_path}: {e}")
+                print(f"Error reading {file_path}: {e}")
 
     # Then process documentation files
     for ext in doc_extensions:
@@ -357,7 +353,7 @@ def read_all_documents(path: str, is_ollama_embedder: bool = None, excluded_dirs
                     # Check token count
                     token_count = count_tokens(content, is_ollama_embedder)
                     if token_count > MAX_EMBEDDING_TOKENS:
-                        logger.warning(f"Skipping large file {relative_path}: Token count ({token_count}) exceeds limit")
+                        print(f"Skipping large file {relative_path}: {token_count} tokens")
                         continue
 
                     doc = Document(
@@ -373,9 +369,9 @@ def read_all_documents(path: str, is_ollama_embedder: bool = None, excluded_dirs
                     )
                     documents.append(doc)
             except Exception as e:
-                logger.error(f"Error reading {file_path}: {e}")
+                print(f"Error reading {file_path}: {e}")
 
-    logger.info(f"Found {len(documents)} documents")
+    print(f"Found {len(documents)} documents")
     return documents
 
 def prepare_data_pipeline(is_ollama_embedder: bool = None):
@@ -486,7 +482,7 @@ def get_github_file_content(repo_url: str, file_path: str, access_token: str = N
         headers = {}
         if access_token:
             headers["Authorization"] = f"token {access_token}"
-        logger.info(f"Fetching file content from GitHub API: {api_url}")
+        # Fetching file content from GitHub API
         try:
             response = requests.get(api_url, headers=headers)
             response.raise_for_status()
@@ -563,12 +559,12 @@ def get_gitlab_file_content(repo_url: str, file_path: str, access_token: str = N
             if project_response.status_code == 200:
                 project_data = project_response.json()
                 default_branch = project_data.get('default_branch', 'main')
-                logger.info(f"Found default branch: {default_branch}")
+                # Found default branch
             else:
-                logger.warning(f"Could not fetch project info, using 'main' as default branch")
+                print("Warning: Could not fetch project info, using 'main' as default branch")
                 default_branch = 'main'
         except Exception as e:
-            logger.warning(f"Error fetching project info: {e}, using 'main' as default branch")
+            print(f"Warning: Error fetching project info: {e}, using 'main' as default branch")
             default_branch = 'main'
 
         api_url = f"{gitlab_domain}/api/v4/projects/{encoded_project_path}/repository/files/{encoded_file_path}/raw?ref={default_branch}"
@@ -576,7 +572,7 @@ def get_gitlab_file_content(repo_url: str, file_path: str, access_token: str = N
         headers = {}
         if access_token:
             headers["PRIVATE-TOKEN"] = access_token
-        logger.info(f"Fetching file content from GitLab API: {api_url}")
+        # Fetching file content from GitLab API
         try:
             response = requests.get(api_url, headers=headers)
             response.raise_for_status()
@@ -634,12 +630,12 @@ def get_bitbucket_file_content(repo_url: str, file_path: str, access_token: str
             if repo_response.status_code == 200:
                 repo_data = repo_response.json()
                 default_branch = repo_data.get('mainbranch', {}).get('name', 'main')
-                logger.info(f"Found default branch: {default_branch}")
+                # Found default branch
             else:
-                logger.warning(f"Could not fetch repository info, using 'main' as default branch")
+                print("Warning: Could not fetch repository info, using 'main' as default branch")
                 default_branch = 'main'
         except Exception as e:
-            logger.warning(f"Error fetching repository info: {e}, using 'main' as default branch")
+            print(f"Warning: Error fetching repository info: {e}, using 'main' as default branch")
             default_branch = 'main'
 
         # Use Bitbucket API to get file content
@@ -650,7 +646,7 @@ def get_bitbucket_file_content(repo_url: str, file_path: str, access_token: str
         headers = {}
         if access_token:
             headers["Authorization"] = f"Bearer {access_token}"
-        logger.info(f"Fetching file content from Bitbucket API: {api_url}")
+        # Fetching file content from Bitbucket API
         try:
             response = requests.get(api_url, headers=headers)
             if response.status_code == 200:
@@ -766,7 +762,7 @@ class DatabaseManager:
             repo_url_or_path (str): The URL or local path of the repository
             access_token (str, optional): Access token for private repositories
         """
-        logger.info(f"Preparing repo storage for {repo_url_or_path}...")
+        print(f"Preparing repo storage for {repo_url_or_path}")
 
         try:
             root_path = get_adalflow_default_root_path()
@@ -776,7 +772,7 @@ class DatabaseManager:
             if repo_url_or_path.startswith("https://") or repo_url_or_path.startswith("http://"):
                 # Extract the repository name from the URL
                 repo_name = self._extract_repo_name_from_url(repo_url_or_path, repo_type)
-                logger.info(f"Extracted repo name: {repo_name}")
+                # Extracted repo name
 
                 save_repo_dir = os.path.join(root_path, "repos", repo_name)
 
@@ -785,7 +781,7 @@ class DatabaseManager:
                     # Only download if the repository doesn't exist or is empty
                     download_repo(repo_url_or_path, save_repo_dir, repo_type, access_token)
                 else:
-                    logger.info(f"Repository already exists at {save_repo_dir}. Using existing repository.")
+                    print(f"Repository already exists at {save_repo_dir}")
             else:  # local path
                 repo_name = os.path.basename(repo_url_or_path)
                 save_repo_dir = repo_url_or_path
@@ -799,10 +795,10 @@ class DatabaseManager:
                 "save_db_file": save_db_file,
             }
             self.repo_url_or_path = repo_url_or_path
-            logger.info(f"Repo paths: {self.repo_paths}")
+            # Repository paths configured
 
         except Exception as e:
-            logger.error(f"Failed to create repository structure: {e}")
+            print(f"Error: Failed to create repository structure: {e}")
             raise
 
     def prepare_db_index(self, is_ollama_embedder: bool = None, excluded_dirs: List[str] = None, excluded_files: List[str] = None,
@@ -823,19 +819,19 @@ class DatabaseManager:
         """
         # check the database
         if self.repo_paths and os.path.exists(self.repo_paths["save_db_file"]):
-            logger.info("Loading existing database...")
+            print("Loading existing database...")
             try:
                 self.db = LocalDB.load_state(self.repo_paths["save_db_file"])
                 documents = self.db.get_transformed_data(key="split_and_embed")
                 if documents:
-                    logger.info(f"Loaded {len(documents)} documents from existing database")
+                    print(f"Loaded {len(documents)} documents from existing database")
                     return documents
             except Exception as e:
-                logger.error(f"Error loading existing database: {e}")
+                print(f"Error loading existing database: {e}")
                 # Continue to create a new database
 
         # prepare the database
-        logger.info("Creating new database...")
+        print("Creating new database...")
         documents = read_all_documents(
             self.repo_paths["save_repo_dir"],
             is_ollama_embedder=is_ollama_embedder,
@@ -847,9 +843,9 @@ class DatabaseManager:
         self.db = transform_documents_and_save_to_db(
             documents, self.repo_paths["save_db_file"], is_ollama_embedder=is_ollama_embedder
         )
-        logger.info(f"Total documents: {len(documents)}")
+        print(f"Total documents: {len(documents)}")
         transformed_docs = self.db.get_transformed_data(key="split_and_embed")
-        logger.info(f"Total transformed documents: {len(transformed_docs)}")
+        print(f"Total transformed documents: {len(transformed_docs)}")
         return transformed_docs
 
     def prepare_retriever(self, repo_url_or_path: str, type: str = "github", access_token: str = None):

api/logging_config.py

@@ -46,9 +46,9 @@ def setup_logging(format: str = None):
             disable_file_logging = True
             default_log_file = None
 
-    # Get log level from environment
-    log_level_str = os.environ.get("LOG_LEVEL", "INFO").upper()
-    log_level = getattr(logging, log_level_str, logging.INFO)
+    # Get log level from environment - default to WARNING to reduce noise in production
+    log_level_str = os.environ.get("LOG_LEVEL", "WARNING").upper()
+    log_level = getattr(logging, log_level_str, logging.WARNING)
 
     # Get log file path (only if file logging is enabled)
     resolved_path = None

api/main.py

@@ -94,8 +94,7 @@ sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 required_env_vars = ['GOOGLE_API_KEY', 'OPENAI_API_KEY']
 missing_vars = [var for var in required_env_vars if not os.environ.get(var)]
 if missing_vars:
-    logger.warning(f"Missing environment variables: {', '.join(missing_vars)}")
-    logger.warning("Some functionality may not work correctly without these variables.")
+    print(f"Warning: Missing environment variables: {', '.join(missing_vars)}")
 
 # Configure Google Generative AI
 import google.generativeai as genai
@@ -104,7 +103,7 @@ from api.config import GOOGLE_API_KEY
 if GOOGLE_API_KEY:
     genai.configure(api_key=GOOGLE_API_KEY)
 else:
-    logger.warning("GOOGLE_API_KEY not configured")
+    print("Warning: GOOGLE_API_KEY not configured")
 
 if __name__ == "__main__":
     # Get port from environment variable or use default
@@ -113,7 +112,7 @@ if __name__ == "__main__":
     # Import the app here to ensure environment variables are set first
     from api.api import app
 
-    logger.info(f"Starting Streaming API on port {port}")
+    print(f"Starting Streaming API on port {port}")
 
     # Run the FastAPI app with uvicorn
     # Disable reload in production/Docker environment

api/simple_chat.py

@@ -82,9 +82,9 @@ async def chat_completions_stream(request: ChatCompletionRequest):
             last_message = request.messages[-1]
             if hasattr(last_message, 'content') and last_message.content:
                 tokens = count_tokens(last_message.content, request.provider == "ollama")
-                logger.info(f"Request size: {tokens} tokens")
+                # Request size check
                 if tokens > 8000:
-                    logger.warning(f"Request exceeds recommended token limit ({tokens} > 7500)")
+                    print(f"Warning: Request exceeds recommended token limit ({tokens} > 7500)")
                     input_too_large = True
 
         # Create a new RAG instance for this request
@@ -99,28 +99,28 @@ async def chat_completions_stream(request: ChatCompletionRequest):
 
             if request.excluded_dirs:
                 excluded_dirs = [unquote(dir_path) for dir_path in request.excluded_dirs.split('\n') if dir_path.strip()]
-                logger.info(f"Using custom excluded directories: {excluded_dirs}")
+                # Using custom excluded directories
             if request.excluded_files:
                 excluded_files = [unquote(file_pattern) for file_pattern in request.excluded_files.split('\n') if file_pattern.strip()]
-                logger.info(f"Using custom excluded files: {excluded_files}")
+                # Using custom excluded files
             if request.included_dirs:
                 included_dirs = [unquote(dir_path) for dir_path in request.included_dirs.split('\n') if dir_path.strip()]
-                logger.info(f"Using custom included directories: {included_dirs}")
+                # Using custom included directories
             if request.included_files:
                 included_files = [unquote(file_pattern) for file_pattern in request.included_files.split('\n') if file_pattern.strip()]
-                logger.info(f"Using custom included files: {included_files}")
+                # Using custom included files
 
             request_rag.prepare_retriever(request.repo_url, request.type, request.token, excluded_dirs, excluded_files, included_dirs, included_files)
-            logger.info(f"Retriever prepared for {request.repo_url}")
+            print(f"Retriever prepared for {request.repo_url}")
         except ValueError as e:
             if "No valid documents with embeddings found" in str(e):
-                logger.error(f"No valid embeddings found: {str(e)}")
+                print(f"Error: No valid embeddings found: {str(e)}")
                 raise HTTPException(status_code=500, detail="No valid document embeddings found. This may be due to embedding size inconsistencies or API errors during document processing. Please try again or check your repository content.")
             else:
-                logger.error(f"ValueError preparing retriever: {str(e)}")
+                print(f"Error: ValueError preparing retriever: {str(e)}")
                 raise HTTPException(status_code=500, detail=f"Error preparing retriever: {str(e)}")
         except Exception as e:
-            logger.error(f"Error preparing retriever: {str(e)}")
+            print(f"Error preparing retriever: {str(e)}")
             # Check for specific embedding-related errors
             if "All embeddings should be of the same size" in str(e):
                 raise HTTPException(status_code=500, detail="Inconsistent embedding sizes detected. Some documents may have failed to embed properly. Please try again.")
@@ -163,7 +163,7 @@ async def chat_completions_stream(request: ChatCompletionRequest):
         # Count research iterations if this is a Deep Research request
         if is_deep_research:
             research_iteration = sum(1 for msg in request.messages if msg.role == 'assistant') + 1
-            logger.info(f"Deep Research request detected - iteration {research_iteration}")
+            print(f"Deep Research request detected - iteration {research_iteration}")
 
             # Check if this is a continuation request
             if "continue" in last_message.content.lower() and "research" in last_message.content.lower():
@@ -172,13 +172,13 @@ async def chat_completions_stream(request: ChatCompletionRequest):
                 for msg in request.messages:
                     if msg.role == "user" and "continue" not in msg.content.lower():
                         original_topic = msg.content.replace("[DEEP RESEARCH]", "").strip()
-                        logger.info(f"Found original research topic: {original_topic}")
+                        # Found original research topic
                         break
 
                 if original_topic:
                     # Replace the continuation message with the original topic
                     last_message.content = original_topic
-                    logger.info(f"Using original topic for research: {original_topic}")
+                    # Using original topic for research
 
         # Get the query from the last message
         query = last_message.content
@@ -194,7 +194,7 @@ async def chat_completions_stream(request: ChatCompletionRequest):
                 if request.filePath:
                     # Use the file path to get relevant context about the file
                     rag_query = f"Contexts related to {request.filePath}"
-                    logger.info(f"Modified RAG query to focus on file: {request.filePath}")
+                    # Modified RAG query to focus on file
 
                 # Try to perform RAG retrieval
                 try:
@@ -204,7 +204,7 @@ async def chat_completions_stream(request: ChatCompletionRequest):
                     if retrieved_documents and retrieved_documents[0].documents:
                         # Format context for the prompt in a more structured way
                         documents = retrieved_documents[0].documents
-                        logger.info(f"Retrieved {len(documents)} documents")
+                        # Retrieved documents
 
                         # Group documents by file path
                         docs_by_file = {}
@@ -227,13 +227,13 @@ async def chat_completions_stream(request: ChatCompletionRequest):
                         # Join all parts with clear separation
                         context_text = "\n\n" + "-" * 10 + "\n\n".join(context_parts)
                     else:
-                        logger.warning("No documents retrieved from RAG")
+                        print("Warning: No documents retrieved from RAG")
                 except Exception as e:
-                    logger.error(f"Error in RAG retrieval: {str(e)}")
+                    print(f"Error in RAG retrieval: {str(e)}")
                     # Continue without RAG if there's an error
 
             except Exception as e:
-                logger.error(f"Error retrieving documents: {str(e)}")
+                print(f"Error retrieving documents: {str(e)}")
                 context_text = ""
 
         # Get repository information
@@ -292,9 +292,9 @@ async def chat_completions_stream(request: ChatCompletionRequest):
         if request.filePath:
             try:
                 file_content = get_file_content(request.repo_url, request.filePath, request.type, request.token)
-                logger.info(f"Successfully retrieved content for file: {request.filePath}")
+                # Successfully retrieved content for file
             except Exception as e:
-                logger.error(f"Error retrieving file content: {str(e)}")
+                print(f"Error retrieving file content: {str(e)}")
                 # Continue without file content if there's an error
 
         # Format conversation history
@@ -321,7 +321,7 @@ async def chat_completions_stream(request: ChatCompletionRequest):
             prompt += f"{CONTEXT_START}\n{context_text}\n{CONTEXT_END}\n\n"
         else:
             # Add a note that we're skipping RAG due to size constraints or because it's the isolated API
-            logger.info("No context available from RAG")
+            # No context available from RAG
             prompt += "<note>Answering without retrieval augmentation.</note>\n\n"
 
         prompt += f"<query>\n{query}\n</query>\n\nAssistant: "
@@ -348,11 +348,11 @@ async def chat_completions_stream(request: ChatCompletionRequest):
                 model_type=ModelType.LLM
             )
         elif request.provider == "openrouter":
-            logger.info(f"Using OpenRouter with model: {request.model}")
+            # Using OpenRouter
 
             # Check if OpenRouter API key is set
             if not OPENROUTER_API_KEY:
-                logger.warning("OPENROUTER_API_KEY not configured, but continuing with request")
+                print("Warning: OPENROUTER_API_KEY not configured")
                 # We'll let the OpenRouterClient handle this and return a friendly error message
 
             model = OpenRouterClient()
@@ -371,11 +371,11 @@ async def chat_completions_stream(request: ChatCompletionRequest):
                 model_type=ModelType.LLM
             )
         elif request.provider == "openai":
-            logger.info(f"Using Openai protocol with model: {request.model}")
+            # Using OpenAI
 
             # Check if an API key is set for Openai
             if not OPENAI_API_KEY:
-                logger.warning("OPENAI_API_KEY not configured, but continuing with request")
+                print("Warning: OPENAI_API_KEY not configured")
                 # We'll let the OpenAIClient handle this and return an error message
 
             # Initialize Openai client
@@ -395,11 +395,11 @@ async def chat_completions_stream(request: ChatCompletionRequest):
                 model_type=ModelType.LLM
             )
         elif request.provider == "bedrock":
-            logger.info(f"Using AWS Bedrock with model: {request.model}")
+            # Using AWS Bedrock
 
             # Check if AWS credentials are set
             if not AWS_ACCESS_KEY_ID or not AWS_SECRET_ACCESS_KEY:
-                logger.warning("AWS_ACCESS_KEY_ID or AWS_SECRET_ACCESS_KEY not configured, but continuing with request")
+                print("Warning: AWS credentials not configured")
                 # We'll let the BedrockClient handle this and return an error message
 
             # Initialize Bedrock client
@@ -416,7 +416,7 @@ async def chat_completions_stream(request: ChatCompletionRequest):
                 model_type=ModelType.LLM
             )
         elif request.provider == "azure":
-            logger.info(f"Using Azure AI with model: {request.model}")
+            # Using Azure AI
 
             # Initialize Azure AI client
             model = AzureAIClient()
@@ -458,18 +458,18 @@ async def chat_completions_stream(request: ChatCompletionRequest):
                 elif request.provider == "openrouter":
                     try:
                         # Get the response and handle it properly using the previously created api_kwargs
-                        logger.info("Making OpenRouter API call")
+                        # Making OpenRouter API call
                         response = await model.acall(api_kwargs=api_kwargs, model_type=ModelType.LLM)
                         # Handle streaming response from OpenRouter
                         async for chunk in response:
                             yield chunk
                     except Exception as e_openrouter:
-                        logger.error(f"Error with OpenRouter API: {str(e_openrouter)}")
+                        print(f"Error with OpenRouter API: {str(e_openrouter)}")
                         yield f"\nError with OpenRouter API: {str(e_openrouter)}\n\nPlease check that you have set the OPENROUTER_API_KEY environment variable with a valid API key."
                 elif request.provider == "openai":
                     try:
                         # Get the response and handle it properly using the previously created api_kwargs
-                        logger.info("Making Openai API call")
+                        # Making OpenAI API call
                         response = await model.acall(api_kwargs=api_kwargs, model_type=ModelType.LLM)
                         # Handle streaming response from Openai
                         async for chunk in response:
@@ -481,12 +481,12 @@ async def chat_completions_stream(request: ChatCompletionRequest):
                                     if text is not None:
                                         yield text
                     except Exception as e_openai:
-                        logger.error(f"Error with Openai API: {str(e_openai)}")
+                        print(f"Error with OpenAI API: {str(e_openai)}")
                         yield f"\nError with Openai API: {str(e_openai)}\n\nPlease check that you have set the OPENAI_API_KEY environment variable with a valid API key."
                 elif request.provider == "bedrock":
                     try:
                         # Get the response and handle it properly using the previously created api_kwargs
-                        logger.info("Making AWS Bedrock API call")
+                        # Making AWS Bedrock API call
                         response = await model.acall(api_kwargs=api_kwargs, model_type=ModelType.LLM)
                         # Handle response from Bedrock (not streaming yet)
                         if isinstance(response, str):
@@ -495,12 +495,12 @@ async def chat_completions_stream(request: ChatCompletionRequest):
                             # Try to extract text from the response
                             yield str(response)
                     except Exception as e_bedrock:
-                        logger.error(f"Error with AWS Bedrock API: {str(e_bedrock)}")
+                        print(f"Error with AWS Bedrock API: {str(e_bedrock)}")
                         yield f"\nError with AWS Bedrock API: {str(e_bedrock)}\n\nPlease check that you have set the AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables with valid credentials."
                 elif request.provider == "azure":
                     try:
                         # Get the response and handle it properly using the previously created api_kwargs
-                        logger.info("Making Azure AI API call")
+                        # Making Azure AI API call
                         response = await model.acall(api_kwargs=api_kwargs, model_type=ModelType.LLM)
                         # Handle streaming response from Azure AI
                         async for chunk in response:
@@ -512,7 +512,7 @@ async def chat_completions_stream(request: ChatCompletionRequest):
                                     if text is not None:
                                         yield text
                     except Exception as e_azure:
-                        logger.error(f"Error with Azure AI API: {str(e_azure)}")
+                        print(f"Error with Azure AI API: {str(e_azure)}")
                         yield f"\nError with Azure AI API: {str(e_azure)}\n\nPlease check that you have set the AZURE_OPENAI_API_KEY, AZURE_OPENAI_ENDPOINT, and AZURE_OPENAI_VERSION environment variables with valid values."
                 else:
                     # Generate streaming response
@@ -523,13 +523,13 @@ async def chat_completions_stream(request: ChatCompletionRequest):
                             yield chunk.text
 
             except Exception as e_outer:
-                logger.error(f"Error in streaming response: {str(e_outer)}")
+                print(f"Error in streaming response: {str(e_outer)}")
                 error_message = str(e_outer)
 
                 # Check for token limit errors
                 if "maximum context length" in error_message or "token limit" in error_message or "too many tokens" in error_message:
                     # If we hit a token limit error, try again without context
-                    logger.warning("Token limit exceeded, retrying without context")
+                    print("Warning: Token limit exceeded, retrying without context")
                     try:
                         # Create a simplified prompt without context
                         simplified_prompt = f"/no_think {system_prompt}\n\n"
@@ -572,14 +572,14 @@ async def chat_completions_stream(request: ChatCompletionRequest):
                                 )
 
                                 # Get the response using the simplified prompt
-                                logger.info("Making fallback OpenRouter API call")
+                                # Making fallback OpenRouter API call
                                 fallback_response = await model.acall(api_kwargs=fallback_api_kwargs, model_type=ModelType.LLM)
 
                                 # Handle streaming fallback_response from OpenRouter
                                 async for chunk in fallback_response:
                                     yield chunk
                             except Exception as e_fallback:
-                                logger.error(f"Error with OpenRouter API fallback: {str(e_fallback)}")
+                                print(f"Error with OpenRouter API fallback: {str(e_fallback)}")
                                 yield f"\nError with OpenRouter API fallback: {str(e_fallback)}\n\nPlease check that you have set the OPENROUTER_API_KEY environment variable with a valid API key."
                         elif request.provider == "openai":
                             try:
@@ -591,7 +591,7 @@ async def chat_completions_stream(request: ChatCompletionRequest):
                                 )
 
                                 # Get the response using the simplified prompt
-                                logger.info("Making fallback Openai API call")
+                                # Making fallback OpenAI API call
                                 fallback_response = await model.acall(api_kwargs=fallback_api_kwargs, model_type=ModelType.LLM)
 
                                 # Handle streaming fallback_response from Openai
@@ -599,7 +599,7 @@ async def chat_completions_stream(request: ChatCompletionRequest):
                                     text = chunk if isinstance(chunk, str) else getattr(chunk, 'text', str(chunk))
                                     yield text
                             except Exception as e_fallback:
-                                logger.error(f"Error with Openai API fallback: {str(e_fallback)}")
+                                print(f"Error with OpenAI API fallback: {str(e_fallback)}")
                                 yield f"\nError with Openai API fallback: {str(e_fallback)}\n\nPlease check that you have set the OPENAI_API_KEY environment variable with a valid API key."
                         elif request.provider == "bedrock":
                             try:
@@ -611,7 +611,7 @@ async def chat_completions_stream(request: ChatCompletionRequest):
                                 )
 
                                 # Get the response using the simplified prompt
-                                logger.info("Making fallback AWS Bedrock API call")
+                                # Making fallback AWS Bedrock API call
                                 fallback_response = await model.acall(api_kwargs=fallback_api_kwargs, model_type=ModelType.LLM)
 
                                 # Handle response from Bedrock
@@ -621,7 +621,7 @@ async def chat_completions_stream(request: ChatCompletionRequest):
                                     # Try to extract text from the response
                                     yield str(fallback_response)
                             except Exception as e_fallback:
-                                logger.error(f"Error with AWS Bedrock API fallback: {str(e_fallback)}")
+                                print(f"Error with AWS Bedrock API fallback: {str(e_fallback)}")
                                 yield f"\nError with AWS Bedrock API fallback: {str(e_fallback)}\n\nPlease check that you have set the AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables with valid credentials."
                         elif request.provider == "azure":
                             try:
@@ -633,7 +633,7 @@ async def chat_completions_stream(request: ChatCompletionRequest):
                                 )
 
                                 # Get the response using the simplified prompt
-                                logger.info("Making fallback Azure AI API call")
+                                # Making fallback Azure AI API call
                                 fallback_response = await model.acall(api_kwargs=fallback_api_kwargs, model_type=ModelType.LLM)
 
                                 # Handle streaming fallback response from Azure AI
@@ -646,7 +646,7 @@ async def chat_completions_stream(request: ChatCompletionRequest):
                                             if text is not None:
                                                 yield text
                             except Exception as e_fallback:
-                                logger.error(f"Error with Azure AI API fallback: {str(e_fallback)}")
+                                print(f"Error with Azure AI API fallback: {str(e_fallback)}")
                                 yield f"\nError with Azure AI API fallback: {str(e_fallback)}\n\nPlease check that you have set the AZURE_OPENAI_API_KEY, AZURE_OPENAI_ENDPOINT, and AZURE_OPENAI_VERSION environment variables with valid values."
                         else:
                             # Initialize Google Generative AI model
@@ -667,7 +667,7 @@ async def chat_completions_stream(request: ChatCompletionRequest):
                                 if hasattr(chunk, 'text'):
                                     yield chunk.text
                     except Exception as e2:
-                        logger.error(f"Error in fallback streaming response: {str(e2)}")
+                        print(f"Error in fallback streaming response: {str(e2)}")
                         yield f"\nI apologize, but your request is too large for me to process. Please try a shorter query or break it into smaller parts."
                 else:
                     # For other errors, return the error message
@@ -680,7 +680,7 @@ async def chat_completions_stream(request: ChatCompletionRequest):
         raise
     except Exception as e_handler:
         error_msg = f"Error in streaming chat completion: {str(e_handler)}"
-        logger.error(error_msg)
+        print(f"Error: {error_msg}")
         raise HTTPException(status_code=500, detail=error_msg)
 
 @app.get("/")

api/websocket_wiki.py

@@ -67,9 +67,9 @@ async def handle_websocket_chat(websocket: WebSocket):
             last_message = request.messages[-1]
             if hasattr(last_message, 'content') and last_message.content:
                 tokens = count_tokens(last_message.content, request.provider == "ollama")
-                logger.info(f"Request size: {tokens} tokens")
+                # Request size check
                 if tokens > 8000:
-                    logger.warning(f"Request exceeds recommended token limit ({tokens} > 7500)")
+                    print(f"Warning: Request exceeds recommended token limit ({tokens} > 7500)")
                     input_too_large = True
 
         # Create a new RAG instance for this request
@@ -84,32 +84,32 @@ async def handle_websocket_chat(websocket: WebSocket):
 
             if request.excluded_dirs:
                 excluded_dirs = [unquote(dir_path) for dir_path in request.excluded_dirs.split('\n') if dir_path.strip()]
-                logger.info(f"Using custom excluded directories: {excluded_dirs}")
+                # Using custom excluded directories
             if request.excluded_files:
                 excluded_files = [unquote(file_pattern) for file_pattern in request.excluded_files.split('\n') if file_pattern.strip()]
-                logger.info(f"Using custom excluded files: {excluded_files}")
+                # Using custom excluded files
             if request.included_dirs:
                 included_dirs = [unquote(dir_path) for dir_path in request.included_dirs.split('\n') if dir_path.strip()]
-                logger.info(f"Using custom included directories: {included_dirs}")
+                # Using custom included directories
             if request.included_files:
                 included_files = [unquote(file_pattern) for file_pattern in request.included_files.split('\n') if file_pattern.strip()]
-                logger.info(f"Using custom included files: {included_files}")
+                # Using custom included files
 
             request_rag.prepare_retriever(request.repo_url, request.type, request.token, excluded_dirs, excluded_files, included_dirs, included_files)
-            logger.info(f"Retriever prepared for {request.repo_url}")
+            print(f"Retriever prepared for {request.repo_url}")
         except ValueError as e:
             if "No valid documents with embeddings found" in str(e):
-                logger.error(f"No valid embeddings found: {str(e)}")
+                print(f"Error: No valid embeddings found: {str(e)}")
                 await websocket.send_text("Error: No valid document embeddings found. This may be due to embedding size inconsistencies or API errors during document processing. Please try again or check your repository content.")
                 await websocket.close()
                 return
             else:
-                logger.error(f"ValueError preparing retriever: {str(e)}")
+                print(f"Error: ValueError preparing retriever: {str(e)}")
                 await websocket.send_text(f"Error preparing retriever: {str(e)}")
                 await websocket.close()
                 return
         except Exception as e:
-            logger.error(f"Error preparing retriever: {str(e)}")
+            print(f"Error preparing retriever: {str(e)}")
             # Check for specific embedding-related errors
             if "All embeddings should be of the same size" in str(e):
                 await websocket.send_text("Error: Inconsistent embedding sizes detected. Some documents may have failed to embed properly. Please try again.")
@@ -158,7 +158,7 @@ async def handle_websocket_chat(websocket: WebSocket):
         # Count research iterations if this is a Deep Research request
         if is_deep_research:
             research_iteration = sum(1 for msg in request.messages if msg.role == 'assistant') + 1
-            logger.info(f"Deep Research request detected - iteration {research_iteration}")
+            print(f"Deep Research request detected - iteration {research_iteration}")
 
             # Check if this is a continuation request
             if "continue" in last_message.content.lower() and "research" in last_message.content.lower():
@@ -167,13 +167,13 @@ async def handle_websocket_chat(websocket: WebSocket):
                 for msg in request.messages:
                     if msg.role == "user" and "continue" not in msg.content.lower():
                         original_topic = msg.content.replace("[DEEP RESEARCH]", "").strip()
-                        logger.info(f"Found original research topic: {original_topic}")
+                        # Found original research topic
                         break
 
                 if original_topic:
                     # Replace the continuation message with the original topic
                     last_message.content = original_topic
-                    logger.info(f"Using original topic for research: {original_topic}")
+                    # Using original topic for research
 
         # Get the query from the last message
         query = last_message.content
@@ -189,7 +189,7 @@ async def handle_websocket_chat(websocket: WebSocket):
                 if request.filePath:
                     # Use the file path to get relevant context about the file
                     rag_query = f"Contexts related to {request.filePath}"
-                    logger.info(f"Modified RAG query to focus on file: {request.filePath}")
+                    # Modified RAG query to focus on file
 
                 # Try to perform RAG retrieval
                 try:
@@ -199,7 +199,7 @@ async def handle_websocket_chat(websocket: WebSocket):
                     if retrieved_documents and retrieved_documents[0].documents:
                         # Format context for the prompt in a more structured way
                         documents = retrieved_documents[0].documents
-                        logger.info(f"Retrieved {len(documents)} documents")
+                        # Retrieved documents
 
                         # Group documents by file path
                         docs_by_file = {}
@@ -222,13 +222,13 @@ async def handle_websocket_chat(websocket: WebSocket):
                         # Join all parts with clear separation
                         context_text = "\n\n" + "-" * 10 + "\n\n".join(context_parts)
                     else:
-                        logger.warning("No documents retrieved from RAG")
+                        print("Warning: No documents retrieved from RAG")
                 except Exception as e:
-                    logger.error(f"Error in RAG retrieval: {str(e)}")
+                    print(f"Error in RAG retrieval: {str(e)}")
                     # Continue without RAG if there's an error
 
             except Exception as e:
-                logger.error(f"Error retrieving documents: {str(e)}")
+                print(f"Error retrieving documents: {str(e)}")
                 context_text = ""
 
         # Get repository information
@@ -392,9 +392,9 @@ This file contains...
         if request.filePath:
             try:
                 file_content = get_file_content(request.repo_url, request.filePath, request.type, request.token)
-                logger.info(f"Successfully retrieved content for file: {request.filePath}")
+                # Successfully retrieved content for file
             except Exception as e:
-                logger.error(f"Error retrieving file content: {str(e)}")
+                print(f"Error retrieving file content: {str(e)}")
                 # Continue without file content if there's an error
 
         # Format conversation history
@@ -421,7 +421,7 @@ This file contains...
             prompt += f"{CONTEXT_START}\n{context_text}\n{CONTEXT_END}\n\n"
         else:
             # Add a note that we're skipping RAG due to size constraints or because it's the isolated API
-            logger.info("No context available from RAG")
+            # No context available from RAG
             prompt += "<note>Answering without retrieval augmentation.</note>\n\n"
 
         prompt += f"<query>\n{query}\n</query>\n\nAssistant: "
@@ -448,11 +448,11 @@ This file contains...
                 model_type=ModelType.LLM
             )
         elif request.provider == "openrouter":
-            logger.info(f"Using OpenRouter with model: {request.model}")
+            # Using OpenRouter
 
             # Check if OpenRouter API key is set
             if not OPENROUTER_API_KEY:
-                logger.warning("OPENROUTER_API_KEY not configured, but continuing with request")
+                print("Warning: OPENROUTER_API_KEY not configured")
                 # We'll let the OpenRouterClient handle this and return a friendly error message
 
             model = OpenRouterClient()
@@ -471,11 +471,11 @@ This file contains...
                 model_type=ModelType.LLM
             )
         elif request.provider == "openai":
-            logger.info(f"Using Openai protocol with model: {request.model}")
+            # Using OpenAI
 
             # Check if an API key is set for Openai
             if not OPENAI_API_KEY:
-                logger.warning("OPENAI_API_KEY not configured, but continuing with request")
+                print("Warning: OPENAI_API_KEY not configured")
                 # We'll let the OpenAIClient handle this and return an error message
 
             # Initialize Openai client
@@ -495,7 +495,7 @@ This file contains...
                 model_type=ModelType.LLM
             )
         elif request.provider == "azure":
-            logger.info(f"Using Azure AI with model: {request.model}")
+            # Using Azure AI
 
             # Initialize Azure AI client
             model = AzureAIClient()
@@ -512,7 +512,7 @@ This file contains...
                 model_type=ModelType.LLM
             )
         elif request.provider == "dashscope":
-            logger.info(f"Using Dashscope with model: {request.model}")
+            # Using Dashscope
 
             # Initialize Dashscope client
             model = DashscopeClient()
@@ -555,7 +555,7 @@ This file contains...
             elif request.provider == "openrouter":
                 try:
                     # Get the response and handle it properly using the previously created api_kwargs
-                    logger.info("Making OpenRouter API call")
+                    # Making OpenRouter API call
                     response = await model.acall(api_kwargs=api_kwargs, model_type=ModelType.LLM)
                     # Handle streaming response from OpenRouter
                     async for chunk in response:
@@ -563,7 +563,7 @@ This file contains...
                     # Explicitly close the WebSocket connection after the response is complete
                     await websocket.close()
                 except Exception as e_openrouter:
-                    logger.error(f"Error with OpenRouter API: {str(e_openrouter)}")
+                    print(f"Error with OpenRouter API: {str(e_openrouter)}")
                     error_msg = f"\nError with OpenRouter API: {str(e_openrouter)}\n\nPlease check that you have set the OPENROUTER_API_KEY environment variable with a valid API key."
                     await websocket.send_text(error_msg)
                     # Close the WebSocket connection after sending the error message
@@ -571,7 +571,7 @@ This file contains...
             elif request.provider == "openai":
                 try:
                     # Get the response and handle it properly using the previously created api_kwargs
-                    logger.info("Making Openai API call")
+                    # Making OpenAI API call
                     response = await model.acall(api_kwargs=api_kwargs, model_type=ModelType.LLM)
                     # Handle streaming response from Openai
                     async for chunk in response:
@@ -585,7 +585,7 @@ This file contains...
                     # Explicitly close the WebSocket connection after the response is complete
                     await websocket.close()
                 except Exception as e_openai:
-                    logger.error(f"Error with Openai API: {str(e_openai)}")
+                    print(f"Error with OpenAI API: {str(e_openai)}")
                     error_msg = f"\nError with Openai API: {str(e_openai)}\n\nPlease check that you have set the OPENAI_API_KEY environment variable with a valid API key."
                     await websocket.send_text(error_msg)
                     # Close the WebSocket connection after sending the error message
@@ -593,7 +593,7 @@ This file contains...
             elif request.provider == "azure":
                 try:
                     # Get the response and handle it properly using the previously created api_kwargs
-                    logger.info("Making Azure AI API call")
+                    # Making Azure AI API call
                     response = await model.acall(api_kwargs=api_kwargs, model_type=ModelType.LLM)
                     # Handle streaming response from Azure AI
                     async for chunk in response:
@@ -607,7 +607,7 @@ This file contains...
                     # Explicitly close the WebSocket connection after the response is complete
                     await websocket.close()
                 except Exception as e_azure:
-                    logger.error(f"Error with Azure AI API: {str(e_azure)}")
+                    print(f"Error with Azure AI API: {str(e_azure)}")
                     error_msg = f"\nError with Azure AI API: {str(e_azure)}\n\nPlease check that you have set the AZURE_OPENAI_API_KEY, AZURE_OPENAI_ENDPOINT, and AZURE_OPENAI_VERSION environment variables with valid values."
                     await websocket.send_text(error_msg)
                     # Close the WebSocket connection after sending the error message
@@ -623,13 +623,13 @@ This file contains...
                 await websocket.close()
 
         except Exception as e_outer:
-            logger.error(f"Error in streaming response: {str(e_outer)}")
+            print(f"Error in streaming response: {str(e_outer)}")
             error_message = str(e_outer)
 
             # Check for token limit errors
             if "maximum context length" in error_message or "token limit" in error_message or "too many tokens" in error_message:
                 # If we hit a token limit error, try again without context
-                logger.warning("Token limit exceeded, retrying without context")
+                print("Warning: Token limit exceeded, retrying without context")
                 try:
                     # Create a simplified prompt without context
                     simplified_prompt = f"/no_think {system_prompt}\n\n"
@@ -672,14 +672,14 @@ This file contains...
                             )
 
                             # Get the response using the simplified prompt
-                            logger.info("Making fallback OpenRouter API call")
+                            # Making fallback OpenRouter API call
                             fallback_response = await model.acall(api_kwargs=fallback_api_kwargs, model_type=ModelType.LLM)
 
                             # Handle streaming fallback_response from OpenRouter
                             async for chunk in fallback_response:
                                 await websocket.send_text(chunk)
                         except Exception as e_fallback:
-                            logger.error(f"Error with OpenRouter API fallback: {str(e_fallback)}")
+                            print(f"Error with OpenRouter API fallback: {str(e_fallback)}")
                             error_msg = f"\nError with OpenRouter API fallback: {str(e_fallback)}\n\nPlease check that you have set the OPENROUTER_API_KEY environment variable with a valid API key."
                             await websocket.send_text(error_msg)
                     elif request.provider == "openai":
@@ -692,7 +692,7 @@ This file contains...
                             )
 
                             # Get the response using the simplified prompt
-                            logger.info("Making fallback Openai API call")
+                            # Making fallback OpenAI API call
                             fallback_response = await model.acall(api_kwargs=fallback_api_kwargs, model_type=ModelType.LLM)
 
                             # Handle streaming fallback_response from Openai
@@ -700,7 +700,7 @@ This file contains...
                                 text = chunk if isinstance(chunk, str) else getattr(chunk, 'text', str(chunk))
                                 await websocket.send_text(text)
                         except Exception as e_fallback:
-                            logger.error(f"Error with Openai API fallback: {str(e_fallback)}")
+                            print(f"Error with OpenAI API fallback: {str(e_fallback)}")
                             error_msg = f"\nError with Openai API fallback: {str(e_fallback)}\n\nPlease check that you have set the OPENAI_API_KEY environment variable with a valid API key."
                             await websocket.send_text(error_msg)
                     elif request.provider == "azure":
@@ -713,7 +713,7 @@ This file contains...
                             )
 
                             # Get the response using the simplified prompt
-                            logger.info("Making fallback Azure AI API call")
+                            # Making fallback Azure AI API call
                             fallback_response = await model.acall(api_kwargs=fallback_api_kwargs, model_type=ModelType.LLM)
 
                             # Handle streaming fallback response from Azure AI
@@ -726,7 +726,7 @@ This file contains...
                                         if text is not None:
                                             await websocket.send_text(text)
                         except Exception as e_fallback:
-                            logger.error(f"Error with Azure AI API fallback: {str(e_fallback)}")
+                            print(f"Error with Azure AI API fallback: {str(e_fallback)}")
                             error_msg = f"\nError with Azure AI API fallback: {str(e_fallback)}\n\nPlease check that you have set the AZURE_OPENAI_API_KEY, AZURE_OPENAI_ENDPOINT, and AZURE_OPENAI_VERSION environment variables with valid values."
                             await websocket.send_text(error_msg)
                     else:
@@ -748,7 +748,7 @@ This file contains...
                             if hasattr(chunk, 'text'):
                                 await websocket.send_text(chunk.text)
                 except Exception as e2:
-                    logger.error(f"Error in fallback streaming response: {str(e2)}")
+                    print(f"Error in fallback streaming response: {str(e2)}")
                     await websocket.send_text(f"\nI apologize, but your request is too large for me to process. Please try a shorter query or break it into smaller parts.")
                     # Close the WebSocket connection after sending the error message
                     await websocket.close()
@@ -759,9 +759,9 @@ This file contains...
                 await websocket.close()
 
     except WebSocketDisconnect:
-        logger.info("WebSocket disconnected")
+        # WebSocket disconnected
     except Exception as e:
-        logger.error(f"Error in WebSocket handler: {str(e)}")
+        print(f"Error in WebSocket handler: {str(e)}")
         try:
             await websocket.send_text(f"Error: {str(e)}")
             await websocket.close()