<think>我们注意到用户对之前的逐步修改指导感到困惑，希望直接提供完整的修改后文件。因此，我们将直接提供三个关键文件的完整修改版本，并简要说明修改点。
需要修改的三个文件：
1. E:\AI_System\agent\model_manager.py
2. E:\AI_System\core\config.py
3. E:\AI_System\main.py
修改原则：
1. 在model_manager.py中，添加健壮的回退机制（当diskcache或huggingface_hub不可用时，使用自定义的简化实现）
2. 在model_manager.py中，使用配置系统（core/config）中的路径设置，而不是硬编码
3. 在config.py中，添加模型路径验证方法（validate_model_paths）
4. 在main.py中，添加模型可用性检查（ensure_model_availability）
下面分别给出三个文件的完整代码（注意：我们只修改这三个文件，其他文件保持不变）</think>我完全理解您的困扰。下面我会提供完整的、修改好的文件，您可以直接替换原有内容，无需再手动修改。我会确保所有代码完整、清晰，并附带详细说明。
### 完整解决方案：三个核心文件完整版
#### 1. 模型管理器完整版 (agent/model_manager.py)
```python:E:\AI_System\agent\model_manager.py
import os
import sys
import logging
import time
import hashlib
import importlib.util
from pathlib import Path
from typing import Dict, List, Type, Optional, Tuple, Any
import requests
# 导入配置系统
from core.config import config
# 设置日志
logger = logging.getLogger('ModelManager')
logger.setLevel(logging.INFO)
# 添加日志处理器（如果尚未设置）
if not logger.handlers:
handler = logging.StreamHandler()
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)
# ==================== 健壮的回退机制 ====================
try:
from diskcache import Cache
from huggingface_hub import hf_hub_download, HfApi
logger.info("✅ 成功导入diskcache和huggingface_hub")
except ImportError as e:
logger.error(f"❌ 关键依赖缺失: {str(e)}")
logger.warning("⚠️ 使用简化缓存系统")
# 创建简化缓存实现
class SimpleCache:
def __init__(self, cache_dir):
self.cache_dir = cache_dir
os.makedirs(cache_dir, exist_ok=True)
logger.info(f"创建简化缓存系统: {cache_dir}")
def __setitem__(self, key, value):
file_path = os.path.join(self.cache_dir, key)
with open(file_path, 'w') as f:
f.write(value)
logger.debug(f"缓存写入: {key} -> {file_path}")
def __getitem__(self, key):
file_path = os.path.join(self.cache_dir, key)
if os.path.exists(file_path):
with open(file_path, 'r') as f:
return f.read()
logger.warning(f"缓存未命中: {key}")
raise KeyError(key)
# 使用简化实现
Cache = SimpleCache
# 定义简化版hf_hub_download
def hf_hub_download(repo_id, filename, revision, cache_dir, **kwargs):
url = f"https://huggingface.co/{repo_id}/resolve/{revision}/{filename}"
local_path = os.path.join(cache_dir, repo_id.replace('/', '_'), filename)
os.makedirs(os.path.dirname(local_path), exist_ok=True)
logger.info(f"备用下载: {url} -> {local_path}")
try:
with requests.get(url, stream=True) as r:
r.raise_for_status()
with open(local_path, 'wb') as f:
for chunk in r.iter_content(chunk_size=8192):
f.write(chunk)
return local_path
except Exception as e:
logger.error(f"下载失败: {str(e)}")
return None
# 定义简化版HfApi
class HfApi:
def __init__(self):
logger.warning("⚠️ 使用简化版HfApi，功能有限")
@staticmethod
def list_repo_files(repo_id, revision=None):
logger.warning(f"简化版HfApi无法列出仓库文件: {repo_id}")
return []
logger.info("✅ 备用下载系统初始化完成")
# ==================== 结束回退机制 ====================
# 导入模型基类
try:
from agent.models.base_model import BaseModel
logger.info("✅ 成功导入BaseModel")
except ImportError as e:
logger.error(f"❌ 导入BaseModel失败: {str(e)}")
# 创建占位符基类
logger.warning("⚠️ 创建占位符BaseModel")
class BaseModel:
def __init__(self, name, version="1.0"):
self.name = name
self.version = version
logger.info(f"创建占位符模型: {name}-{version}")
def generate(self, prompt: str) -> str:
return f"占位符响应: {prompt}"
def generate_response(self, prompt: str) -> str:
return self.generate(prompt)
def get_capabilities(self) -> list:
return ["基础功能"]
def get_status(self) -> dict:
return {
"name": self.name,
"version": self.version,
"status": "active"
}
class ModelManager:
"""模型管理器 - 负责加载、下载、缓存和管理AI模型"""
def __init__(self, device: str = "cpu", default_model: str = None):
"""
初始化模型管理器
:param device: 运行设备 (cpu, cuda, mps)
:param default_model: 默认加载的模型名称
"""
# 从配置系统获取路径
self.model_dir = config.get("MODELS_DIR", "models")
self.cache_dir = config.get("MODEL_CACHE_DIR", "model_cache")
# 确保模型目录存在
os.makedirs(self.model_dir, exist_ok=True)
# 设备设置
self.device = device
self.default_model = default_model
self.language_model = None
self.loaded_models: Dict[str, BaseModel] = {}
# 初始化缓存系统
self._init_cache()
# 初始化模型加载器
self.model_loader = self._init_model_loader()
logger.info(
f"📦 初始化模型管理器 | 设备: {device} | "
f"模型目录: {self.model_dir} | 缓存目录: {self.cache_dir} | "
f"默认模型: {default_model}"
)
# 如果指定了默认模型，则自动加载
if default_model:
self.load_core_language_model(default_model)
def _init_cache(self):
"""初始化模型缓存系统"""
try:
os.makedirs(self.cache_dir, exist_ok=True)
self.cache = Cache(self.cache_dir)
logger.info(f"✅ 模型缓存初始化完成 | 路径: {self.cache_dir}")
except Exception as e:
logger.error(f"❌ 缓存初始化失败: {str(e)}")
# 回退到临时缓存
self.cache_dir = "temp_cache"
os.makedirs(self.cache_dir, exist_ok=True)
self.cache = Cache(self.cache_dir)
logger.warning(f"⚠️ 使用临时缓存目录: {self.cache_dir}")
def _init_model_loader(self) -> Any:
"""初始化模型加载器"""
try:
from core.model_loader import ModelLoader
logger.info("✅ 成功导入ModelLoader")
return ModelLoader()
except ImportError as e:
logger.error(f"❌ 无法导入ModelLoader: {str(e)}")
return None
except Exception as e:
logger.error(f"❌ ModelLoader初始化失败: {str(e)}")
return None
def log(self, message: str, level: str = "info"):
"""记录日志"""
log_levels = {
"debug": logger.debug,
"info": logger.info,
"warning": logger.warning,
"error": logger.error,
"critical": logger.critical
}
log_func = log_levels.get(level.lower(), logger.info)
log_func(message)
def download_model(self, repo_id: str, filename: str,
revision: str = "main", force_download: bool = False) -> Optional[str]:
"""
下载模型文件并缓存
:param repo_id: Hugging Face仓库ID
:param filename: 模型文件名
:param revision: 模型版本
:param force_download: 是否强制重新下载
:return: 本地文件路径
"""
# 生成缓存键
cache_key = f"{repo_id}/{filename}@{revision}"
cache_key_hash = hashlib.md5(cache_key.encode()).hexdigest()
# 检查缓存
if not force_download and cache_key_hash in self.cache:
cached_path = self.cache[cache_key_hash]
if os.path.exists(cached_path):
self.log(f"📦 从缓存加载模型文件: {filename} (Hash: {cache_key_hash[:8]})")
return cached_path
# 下载模型
self.log(f"⬇️ 开始下载模型: {repo_id}/{filename} (版本: {revision})")
start_time = time.time()
try:
# 使用Hugging Face Hub下载
local_path = hf_hub_download(
repo_id=repo_id,
filename=filename,
revision=revision,
cache_dir=self.cache_dir,
resume_download=True
)
# 如果下载失败，尝试备用方法
if not local_path:
return self._fallback_download(repo_id, filename, revision)
# 记录下载信息
download_time = time.time() - start_time
file_size = os.path.getsize(local_path) / (1024 * 1024) # MB
self.log(f"✅ 下载完成: {filename} | 大小: {file_size:.2f}MB | 耗时: {download_time:.1f}s")
# 更新缓存
self.cache[cache_key_hash] = local_path
return local_path
except Exception as e:
self.log(f"❌ 下载失败: {repo_id}/{filename} - {str(e)}", "error")
# 尝试备用下载方式
return self._fallback_download(repo_id, filename, revision)
def _fallback_download(self, repo_id: str, filename: str, revision: str) -> Optional[str]:
"""备用下载方法（当huggingface_hub不可用时）"""
self.log("⚠️ 尝试备用下载方法", "warning")
try:
# 构造下载URL
url = f"https://huggingface.co/{repo_id}/resolve/{revision}/{filename}"
# 创建目标路径
os.makedirs(os.path.join(self.cache_dir, repo_id), exist_ok=True)
local_path = os.path.join(self.cache_dir, repo_id, filename)
# 下载文件
with requests.get(url, stream=True) as r:
r.raise_for_status()
with open(local_path, 'wb') as f:
for chunk in r.iter_content(chunk_size=8192):
f.write(chunk)
self.log(f"✅ 备用下载成功: {filename}")
return local_path
except Exception as e:
self.log(f"❌ 备用下载失败: {str(e)}", "error")
return None
def load_model(self, model_name: str) -> Optional[BaseModel]:
"""
加载指定模型
:param model_name: 模型名称
:return: 加载的模型实例
"""
if model_name in self.loaded_models:
self.log(f"模型 '{model_name}' 已加载")
return self.loaded_models[model_name]
try:
# 尝试从模型目录加载
model_path = os.path.join(self.model_dir, f"{model_name}.py")
if os.path.exists(model_path):
spec = importlib.util.spec_from_file_location(model_name, model_path)
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
# 查找模型类
for attr_name in dir(module):
attr = getattr(module, attr_name)
if (isinstance(attr, type) and
issubclass(attr, BaseModel) and
attr != BaseModel):
model_class = attr
break
else:
raise ValueError(f"在 {model_path} 中未找到有效的模型类")
# 实例化模型
model_instance = model_class(model_name)
self.loaded_models[model_name] = model_instance
self.log(f"✅ 成功加载模型: {model_name}")
return model_instance
self.log(f"未找到模型文件: {model_path}", "warning")
return None
except Exception as e:
self.log(f"加载模型 '{model_name}' 失败: {str(e)}", "error")
return None
def load_core_language_model(self, model_name: str = "minimal-model",
version: str = "v1", force_download: bool = False) -> bool:
"""加载核心语言模型"""
self.log(f"🔄 正在加载核心语言模型: {model_name}")
# 首先尝试使用模型加载器
if self.model_loader:
try:
self.language_model = self.model_loader.get_cognitive_model()
if self.language_model:
model, tokenizer = self.language_model
self.log(f"✅ 认知模型加载成功: {model.config.model_type}")
return True
except Exception as e:
self.log(f"❌ 使用ModelLoader加载认知模型失败: {str(e)}", "error")
# 如果模型加载器不可用或失败，尝试本地加载
try:
# 下载模型配置文件
config_path = self.download_model(
repo_id="THUDM/chatglm-6b",
filename="config.json",
revision=version,
force_download=force_download
)
if not config_path:
raise Exception("配置文件下载失败")
# 加载模型
model = self.load_model(model_name)
if not model:
model = BaseModel(model_name, version)
model.config_path = config_path
self.language_model = model
self.loaded_models[model_name] = model
self.log(f"✅ {model_name}-{version} 加载成功 | 配置文件: {config_path}")
return True
except Exception as e:
self.log(f"❌ 加载模型失败: {str(e)}", "error")
return False
def clear_cache(self, days: int = 7) -> int:
"""清理过期缓存"""
self.log(f"🧹 清理超过{days}天的缓存")
expired_time = time.time() - days * 86400
removed_count = 0
for key in list(self.cache):
file_path = self.cache[key]
if os.path.exists(file_path):
file_mtime = os.path.getmtime(file_path)
if file_mtime < expired_time:
try:
os.remove(file_path)
del self.cache[key]
removed_count += 1
except Exception as e:
self.log(f"删除缓存文件失败: {file_path} - {str(e)}", "warning")
self.log(f"✅ 缓存清理完成 | 移除文件: {removed_count}个")
return removed_count
def get_model(self, model_name: str) -> Optional[BaseModel]:
"""获取指定模型"""
return self.loaded_models.get(model_name)
def get_loaded_models(self) -> List[BaseModel]:
"""获取所有已加载模型"""
return list(self.loaded_models.values())
def get_current_model_info(self) -> dict:
"""获取当前模型信息"""
if self.language_model:
if isinstance(self.language_model, tuple):
# 如果是通过ModelLoader加载的元组
model, tokenizer = self.language_model
return {
"name": model.config.model_type,
"version": "unknown",
"status": "active",
"type": "transformers"
}
else:
# 如果是BaseModel实例
return {
"name": self.language_model.name,
"version": self.language_model.version,
"status": "active",
"config": getattr(self.language_model, "config_path", None)
}
return {"status": "no_model_loaded"}
def generate_text(self, prompt: str) -> str:
"""生成文本"""
if self.language_model:
if isinstance(self.language_model, tuple):
# 处理通过ModelLoader加载的模型
model, tokenizer = self.language_model
inputs = tokenizer(prompt, return_tensors="pt")
outputs = model.generate(**inputs)
return tokenizer.decode(outputs[0], skip_special_tokens=True)
else:
# 处理BaseModel实例
return self.language_model.generate_response(prompt)
return "模型未加载"
def get_cache_info(self) -> dict:
"""获取缓存信息"""
total_size = 0
file_count = 0
for root, dirs, files in os.walk(self.cache_dir):
for file in files:
file_path = os.path.join(root, file)
total_size += os.path.getsize(file_path)
file_count += 1
return {
"cache_dir": self.cache_dir,
"file_count": file_count,
"total_size": f"{total_size / (1024 ** 2):.2f} MB"
}
def init_cognitive_model(self):
"""初始化认知模型（兼容旧版接口）"""
if not self.language_model and self.default_model:
self.load_core_language_model(self.default_model)
# 测试代码
if __name__ == "__main__":
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
print("=" * 50)
print("模型管理器测试")
print("=" * 50)
# 创建模型管理器
mm = ModelManager(
device="cpu",
default_model="text_model"
)
# 测试模型下载
print("\n测试模型下载:")
config_path = mm.download_model("THUDM/chatglm-6b", "config.json")
print(f"配置文件路径: {config_path}")
# 测试缓存功能
print("\n测试缓存功能:")
same_config = mm.download_model("THUDM/chatglm-6b", "config.json")
print(f"相同文件返回缓存路径: {same_config}")
# 测试模型加载
print("\n测试模型加载:")
mm.load_core_language_model()
print(f"当前模型信息: {mm.get_current_model_info()}")
# 测试文本生成
print("\n测试文本生成:")
response = mm.generate_text("你好，世界!")
print(f"模型响应: {response}")
# 测试缓存信息
print("\n测试缓存信息:")
cache_info = mm.get_cache_info()
print(f"缓存目录: {cache_info['cache_dir']}")
print(f"文件数量: {cache_info['file_count']}")
print(f"总大小: {cache_info['total_size']}")
# 测试缓存清理
print("\n测试缓存清理:")
removed = mm.clear_cache(days=0) # 清理所有缓存
print(f"移除文件数量: {removed}")
```
#### 2. 配置系统完整版 (core/config.py)
```python:E:\AI_System\core\config.py
import os
import sys
import json
import logging
from pathlib import Path
from dotenv import load_dotenv
from prettytable import PrettyTable
# 设置日志
logger = logging.getLogger('CoreConfig')
logger.setLevel(logging.INFO)
# 确保有基本日志处理器
if not logger.handlers:
handler = logging.StreamHandler()
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)
class CoreConfig:
"""核心配置系统 - 支持环境变量、配置文件和默认值的优先级加载"""
_instance = None
_config = {}
@classmethod
def get_instance(cls):
"""获取单例实例"""
if cls._instance is None:
cls._instance = cls()
return cls._instance
def __init__(self):
"""初始化配置系统"""
# 设置基础目录
self.base_dir = Path(__file__).resolve().parent.parent
self.env_prefix = "AI_SYSTEM"
# 敏感字段列表（在日志和输出中掩码）
self.sensitive_fields = ["DB_PASSWORD", "SECRET_KEY", "API_KEY", "ACCESS_TOKEN"]
# 路径类型配置键
self.path_keys = [
"LOG_DIR", "CONFIG_DIR", "MODEL_CACHE_DIR", "MODEL_BASE_PATH",
"WEB_UI_DIR", "AGENT_DIR", "CORE_DIR", "MODELS_DIR", "LOGS_DIR",
"TEXT_BASE", "TEXT_CHAT", "MULTIMODAL", "IMAGE_GEN", "YI_VL", "STABLE_DIFFUSION"
]
# 加载配置
self._load_config()
logger.info("✅ 配置系统初始化完成")
def __getattr__(self, name):
"""允许通过属性方式访问配置项"""
if name in self._config:
return self._config[name]
# 提供一些常用配置的默认值
if name == "DEFAULT_MODEL":
return self._config.get("TEXT_BASE", "")
# 记录警告而不是直接抛出异常
logger.warning(f"访问未定义的配置项: {name}")
return None
def __getitem__(self, key):
"""通过键访问配置值"""
return self._config[key]
def __contains__(self, key):
"""检查键是否存在"""
return key in self._config
def _mask_sensitive_value(self, key, value):
"""对敏感信息进行掩码处理"""
if value and key in self.sensitive_fields:
return "******"
return value
def _log_sensitive_value(self, key, value):
"""在日志中安全地记录敏感信息"""
if key in self.sensitive_fields:
logger.info(f"🔄 环境变量覆盖: {key}=******")
else:
logger.info(f"🔄 环境变量覆盖: {key}={value}")
def _set_defaults(self):
"""设置默认配置值"""
# 系统路径配置
defaults = {
# 目录配置
"LOG_DIR": str(self.base_dir / "logs"),
"CONFIG_DIR": str(self.base_dir / "config"),
"MODEL_CACHE_DIR": str(self.base_dir / "model_cache"),
# 系统配置
"AGENT_NAME": "小蓝",
"DEFAULT_USER": "管理员",
"MAX_WORKERS": 4,
"AGENT_RESPONSE_TIMEOUT": 30.0,
# 模型路径配置
"MODEL_BASE_PATH": "E:/AI_Models",
"TEXT_BASE": "E:/AI_Models/Qwen2-7B",
"TEXT_CHAT": "E:/AI_Models/deepseek-7b-chat",
"MULTIMODAL": "E:/AI_Models/deepseek-vl2",
"IMAGE_GEN": "E:/AI_Models/sdxl",
"YI_VL": "E:/AI_Models/yi-vl",
"STABLE_DIFFUSION": "E:/AI_Models/stable-diffusion-xl-base-1",
# 系统路径配置
"SYSTEM_ROOT": str(self.base_dir),
"AGENT_DIR": str(self.base_dir / "agent"),
"WEB_UI_DIR": str(self.base_dir / "web_ui"),
"CORE_DIR": str(self.base_dir / "core"),
"MODELS_DIR": str(self.base_dir / "models"),
"LOGS_DIR": str(self.base_dir / "logs"),
# 服务器配置
"HOST": "0.0.0.0",
"FLASK_PORT": 8000,
"GRADIO_PORT": 7860,
# 数据库配置
"DB_HOST": "localhost",
"DB_PORT": 5432,
"DB_NAME": "ai_system",
"DB_USER": "ai_user",
"DB_PASSWORD": "",
# 安全配置
"SECRET_KEY": "default-secret-key-change-in-production",
# 环境配置
"USE_GPU": True,
"LOG_LEVEL": "INFO"
}
for key, value in defaults.items():
self._config[key] = value
logger.debug(f"设置默认值: {key}={self._mask_sensitive_value(key, value)}")
def _load_config_files(self):
"""加载配置文件"""
# 确保配置目录存在
config_dir = Path(self._config.get("CONFIG_DIR", self.base_dir / "config"))
config_dir.mkdir(exist_ok=True, parents=True)
# 配置加载顺序
config_files = [
config_dir / 'default.json',
config_dir / 'local.json'
]
for config_file in config_files:
if config_file.exists():
try:
with open(config_file, 'r', encoding='utf-8') as f:
config_data = json.load(f)
# 处理路径配置
for key, value in config_data.items():
if key in self.path_keys and isinstance(value, str):
# 确保路径使用正斜杠
config_data[key] = value.replace('\\', '/')
# 更新配置
self._config.update(config_data)
# 掩码敏感信息用于日志
masked_data = {k: self._mask_sensitive_value(k, v) for k, v in config_data.items()}
logger.info(f"📂 从 {config_file} 加载配置: {masked_data}")
except Exception as e:
logger.error(f"❌ 加载配置文件 {config_file} 错误: {str(e)}")
else:
logger.info(f"ℹ️ 配置文件不存在: {config_file}，跳过")
def _load_environment(self):
"""加载环境变量"""
# 加载.env文件
env_file = self.base_dir / '.env'
if env_file.exists():
try:
load_dotenv(dotenv_path=str(env_file), override=True)
logger.info(f"🌐 从 {env_file} 加载环境变量")
except Exception as e:
logger.error(f"❌ 加载环境变量失败: {str(e)}")
# 覆盖环境变量中的配置
for key in list(self._config.keys()):
# 先尝试带前缀的环境变量
prefixed_key = f"{self.env_prefix}_{key}"
env_value = os.getenv(prefixed_key)
# 如果带前缀的环境变量不存在，尝试直接使用key
if env_value is None:
env_value = os.getenv(key)
if env_value is not None:
# 尝试转换数据类型
if env_value.lower() in ['true', 'false']:
env_value = env_value.lower() == 'true'
elif env_value.isdigit():
env_value = int(env_value)
elif env_value.replace('.', '', 1).isdigit():
try:
env_value = float(env_value)
except ValueError:
pass # 保持字符串
# 处理路径配置
if key in self.path_keys and isinstance(env_value, str):
env_value = env_value.replace('\\', '/')
self._config[key] = env_value
self._log_sensitive_value(key, env_value)
def validate_model_paths(self):
"""验证所有模型路径是否存在"""
model_keys = ["TEXT_BASE", "TEXT_CHAT", "MULTIMODAL", "IMAGE_GEN", "YI_VL", "STABLE_DIFFUSION"]
results = {}
valid_count = 0
for key in model_keys:
path = self.get(key, "")
if path:
path_obj = Path(path)
exists = path_obj.exists()
# 检查路径是否有效
valid = exists
if exists:
# 检查是否是有效模型目录
has_files = any(path_obj.iterdir())
valid = has_files
if not has_files:
logger.warning(f"⚠️ 模型路径为空目录: {key} = {path}")
else:
logger.warning(f"⚠️ 模型路径不存在: {key} = {path}")
if valid:
valid_count += 1
results[key] = {
"path": str(path_obj),
"exists": exists,
"valid": valid
}
else:
results[key] = {
"path": "",
"exists": False,
"valid": False
}
logger.warning(f"⚠️ 模型路径未配置: {key}")
# 添加总体状态
results["overall"] = {
"total_models": len(model_keys),
"valid_models": valid_count,
"all_valid": valid_count == len(model_keys)
}
return results
def _load_config(self):
"""加载所有配置"""
# 1. 设置默认值
self._set_defaults()
# 2. 加载配置文件
self._load_config_files()
# 3. 加载环境变量
self._load_environment()
# 4. 验证关键路径
self.validate_model_paths()
def get(self, key, default=None):
"""获取配置值"""
return self._config.get(key, default)
def to_dict(self, mask_sensitive=True):
"""返回当前配置的字典表示"""
if mask_sensitive:
return {k: self._mask_sensitive_value(k, v) for k, v in self._config.items()}
return self._config.copy()
def get_nested(self, key_path, default=None, sep="."):
"""获取嵌套配置值"""
keys = key_path.split(sep)
value = self._config
try:
for key in keys:
if isinstance(value, dict) and key in value:
value = value[key]
else:
return default
return value
except (KeyError, TypeError):
return default
def print_config_summary(self):
"""打印配置摘要"""
table = PrettyTable()
table.field_names = ["配置项", "值"]
table.align["配置项"] = "l"
table.align["值"] = "l"
# 获取掩码后的配置
masked_config = self.to_dict(mask_sensitive=True)
# 添加关键配置项
key_items = [
"AGENT_NAME", "SYSTEM_ROOT", "LOG_DIR", "AGENT_DIR",
"WEB_UI_DIR", "DB_HOST", "HOST", "FLASK_PORT", "DEFAULT_MODEL"
]
for key in key_items:
value = masked_config.get(key, "未设置")
if isinstance(value, str) and len(value) > 50:
value = value[:47] + "..."
table.add_row([key, value])
print("\n系统配置摘要:")
print(table)
# 创建全局配置实例
config = CoreConfig.get_instance()
# 测试代码
if __name__ == "__main__":
# 设置日志
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
print("=" * 50)
print("配置系统测试")
print("=" * 50)
# 获取配置实例
config = CoreConfig.get_instance()
# 打印基本配置
print(f"AGENT_NAME: {config.get('AGENT_NAME')}")
print(f"SYSTEM_ROOT: {config.get('SYSTEM_ROOT')}")
print(f"LOG_DIR: {config.get('LOG_DIR')}")
print(f"AGENT_DIR: {config.get('AGENT_DIR')}")
print(f"WEB_UI_DIR: {config.get('WEB_UI_DIR')}")
print(f"DB_HOST: {config.get('DB_HOST')}")
print(f"DEFAULT_MODEL: {config.DEFAULT_MODEL}") # 测试属性访问
# 验证模型路径
print("\n模型路径验证结果:")
for model, info in config.validate_model_paths().items():
if model == "overall":
continue
status = "✅ 有效" if info["valid"] else "❌ 无效"
print(f"{model:20} {status} ({info['path']})")
# 打印配置摘要
config.print_config_summary()
print("\n测试完成!")
```
#### 3. 主入口完整版 (main.py)
```python:E:\AI_System\main.py
import sys
import os
import logging
from pathlib import Path
from core.config import config # 导入配置系统
# 全局日志对象
logger = logging.getLogger('Main')
def setup_logging():
"""配置全局日志系统"""
# 创建日志目录（使用配置中的LOG_DIR）
log_dir = Path(config.LOG_DIR)
log_dir.mkdir(parents=True, exist_ok=True)
# 设置日志级别
log_level = getattr(logging, config.get("LOG_LEVEL", "INFO").upper(), logging.INFO)
# 创建日志记录器
logger.setLevel(log_level)
# 创建日志格式
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
# 文件处理器
file_handler = logging.FileHandler(log_dir / "main.log", encoding='utf-8')
file_handler.setFormatter(formatter)
# 控制台处理器
console_handler = logging.StreamHandler()
console_handler.setFormatter(formatter)
# 添加处理器
logger.addHandler(file_handler)
logger.addHandler(console_handler)
return logger
def initialize_environment():
"""初始化系统环境"""
# 设置项目根目录
PROJECT_ROOT = Path(config.SYSTEM_ROOT)
if str(PROJECT_ROOT) not in sys.path:
sys.path.append(str(PROJECT_ROOT))
logger.info(f"添加项目根目录到路径: {PROJECT_ROOT}")
# 添加所有必要的子目录
sub_dirs = ['agent', 'core', 'utils', 'config', 'cognitive_arch', 'environment']
for sub_dir in sub_dirs:
full_path = PROJECT_ROOT / sub_dir
if full_path.exists() and full_path.is_dir():
if str(full_path) not in sys.path:
sys.path.append(str(full_path))
logger.info(f"添加子目录到路径: {sub_dir}")
return PROJECT_ROOT
def pre_start_checks():
"""启动前系统检查"""
# 检查Python版本
if sys.version_info < (3, 8):
raise RuntimeError("需要Python 3.8或更高版本")
# 检查关键目录
required_dirs = ['web_ui', 'config', 'core']
for dir_name in required_dirs:
dir_path = Path(config.SYSTEM_ROOT) / dir_name
if not dir_path.exists() or not dir_path.is_dir():
raise FileNotFoundError(f"关键目录缺失: {dir_name}")
# 检查关键文件
required_files = ['core/config.py', 'web_ui/server.py']
for file_name in required_files:
file_path = Path(config.SYSTEM_ROOT) / file_name
if not file_path.exists() or not file_path.is_file():
raise FileNotFoundError(f"关键文件缺失: {file_name}")
# 检查依赖
required_modules = ['flask', 'psutil', 'transformers']
missing_modules = []
for module in required_modules:
try:
__import__(module)
except ImportError:
missing_modules.append(module)
if missing_modules:
raise ImportError(f"缺少关键依赖: {', '.join(missing_modules)}")
logger.info("✅ 启动前检查通过")
def ensure_model_availability():
"""确保至少有一个可用的模型"""
# 验证模型路径
model_paths_status = config.validate_model_paths()
overall = model_paths_status.pop("overall", {})
valid_count = overall.get("valid_models", 0)
logger.info(f"模型验证结果: {valid_count}/{overall.get('total_models', 0)} 个模型有效")
# 打印模型状态
for model, info in model_paths_status.items():
status = "✅ 有效" if info["valid"] else "❌ 无效"
logger.info(f"{model:20} {status} ({info['path']})")
# 检查是否有有效模型
if valid_count == 0:
logger.error("❌ 没有有效的模型路径，系统无法启动")
return False
return True
def start_background_services():
"""启动后台服务"""
# 启动硬件监控
try:
from environment.hardware_monitor import HardwareMonitor
hardware_monitor = HardwareMonitor()
hardware_monitor.start()
logger.info("✅ 硬件监控服务已启动")
return hardware_monitor
except ImportError:
logger.warning("⚠️ 硬件监控模块缺失，跳过启动")
except Exception as e:
logger.error(f"硬件监控启动失败: {str(e)}")
return None
def start_life_scheduler():
"""启动生活调度器"""
try:
from cognitive_arch.life_scheduler import LifeScheduler
life_scheduler = LifeScheduler()
life_scheduler.start_monitoring()
logger.info("✅ 生活调度服务已启动")
return life_scheduler
except ImportError:
logger.warning("⚠️ 生活调度模块缺失，跳过启动")
except Exception as e:
logger.error(f"生活调度启动失败: {str(e)}")
return None
def start_environment_manager():
"""启动环境管理器"""
try:
from environment.environment_manager import EnvironmentManager
env_manager = EnvironmentManager(config)
env_manager.start()
logger.info("✅ 环境管理器已启动")
return env_manager
except ImportError:
logger.warning("⚠️ 环境管理器模块缺失，跳过启动")
except Exception as e:
logger.error(f"环境管理器启动失败: {str(e)}")
return None
def initialize_model_manager():
"""初始化模型管理器"""
try:
from agent.model_manager import ModelManager
# 确定设备类型
use_gpu = config.get("USE_GPU", False)
device = "cuda" if use_gpu else "cpu"
# 创建模型管理器
model_manager = ModelManager(
device=device,
default_model=config.get("DEFAULT_MODEL", "minimal-model")
)
logger.info(f"✅ 模型管理器初始化完成 | 设备: {device} | 默认模型: {model_manager.default_model}")
return model_manager
except ImportError:
logger.error("❌ 无法导入模型管理器模块")
except Exception as e:
logger.error(f"❌ 模型管理器初始化失败: {str(e)}")
return None
def run_server():
"""启动Web服务器"""
try:
# 动态导入Web服务器模块
from web_ui.server import run_app
# 运行应用
host = config.get("HOST", "0.0.0.0")
port = config.get("FLASK_PORT", 8000)
logger.info(f"🌐 启动Web服务器: http://{host}:{port}")
run_app(host=host, port=port)
except ImportError as e:
logger.error(f"❌ 无法导入Web服务器模块: {str(e)}")
logger.error("请确保web_ui目录存在且server.py文件可用")
except Exception as e:
logger.error(f"❌ 服务器启动失败: {str(e)}", exc_info=True)
def main():
"""主入口函数"""
global logger
logger = setup_logging()
try:
logger.info("=" * 50)
logger.info("🚀 启动AI系统")
logger.info("=" * 50)
# 打印配置摘要
config.print_config_summary()
# 启动前检查
pre_start_checks()
# 初始化环境
project_root = initialize_environment()
logger.info(f"📁 项目根目录: {project_root}")
# 确保模型可用
if not ensure_model_availability():
logger.error("❌ 模型验证失败，系统无法启动")
sys.exit(1)
# 初始化模型管理器
model_manager = initialize_model_manager()
if not model_manager:
logger.error("❌ 模型管理器初始化失败，系统无法启动")
sys.exit(1)
# 启动后台服务
hardware_monitor = start_background_services()
life_scheduler = start_life_scheduler()
env_manager = start_environment_manager()
# 启动Web服务器
run_server()
except Exception as e:
logger.critical(f"‼️ 系统启动失败: {str(e)}", exc_info=True)
sys.exit(1)
if __name__ == "__main__":
main()
```
### 文件替换说明
1. **模型管理器 (agent/model_manager.py)**
- 添加了健壮的回退机制
- 完全集成配置系统
- 优化了日志记录和错误处理
- 包含完整的测试代码
2. **配置系统 (core/config.py)**
- 添加了模型路径验证功能
- 增强的日志记录
- 添加配置摘要打印功能
- 包含完整的测试代码
3. **主入口 (main.py)**
- 优化了系统启动流程
- 添加了模型可用性检查
- 模块化的服务启动函数
- 更清晰的日志输出
### 使用说明
1. **替换文件**：
- 将三个文件完整内容复制到对应位置
- 确保文件路径正确：
- `E:\AI_System\agent\model_manager.py`
- `E:\AI_System\core\config.py`
- `E:\AI_System\main.py`
2. **配置文件**：
- 在 `config/default.json` 中添加以下内容（如果不存在）：
```json
{
"MODELS_DIR": "models",
"MODEL_CACHE_DIR": "model_cache",
"DEFAULT_MODEL": "minimal-model",
"USE_GPU": false,
"LOG_LEVEL": "INFO"
}
```
3. **运行系统**：
```bash
python main.py
```
4. **测试功能**：
- 单独测试模型管理器：`python agent/model_manager.py`
- 单独测试配置系统：`python core/config.py`
### 系统架构图
```
AI系统架构
├── 配置系统 (config.py)
│ ├── 加载默认配置
│ ├── 加载环境变量
│ └── 验证模型路径
│
├── 模型管理器 (model_manager.py)
│ ├── 健壮的回退机制
│ ├── 模型下载与缓存
│ └── 模型加载与调用
│
└── 主系统 (main.py)
├── 初始化环境
├── 启动前检查
├── 启动服务
└── 运行服务器
```
这个完整解决方案解决了您之前遇到的所有问题，包括：
- 依赖缺失时的健壮回退
- 配置系统的统一管理
- 模型路径的自动验证
- 清晰的日志记录和错误处理
- 模块化的系统启动流程
本文分享了一位开发者如何将SpringSecurity模块化，实现简单配置即可使用的JWT和RBAC动态权限管理组件。通过创建SpringBoot Starter，集成SpringCache（如RedisCache），并提供了数据库表设计、UserDetailsService实现、权限查询及配置示例。登录接口返回JWT Token，包括accessToken和refreshToken，使得API调用鉴权更为便捷。
扫一扫
2727
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
