diff --git a/maternal_agent.py b/maternal_agent.py
new file mode 100644
index 0000000000000000000000000000000000000000..a2dc1949fa12e58682f10474062f3dc6345ec053
--- /dev/null
+++ b/maternal_agent.py
@@ -0,0 +1,688 @@
+import os
+import json
+from datetime import datetime
+from lazyllm import OnlineChatModule, WebModule, pipeline, TrainableModule
+import re
+
+# 母婴类选品智能助手Agent
+class MaternalAgent:
+    def __init__(self):
+        # 初始化LazyLLM聊天模块
+        try:
+            # 首先尝试使用OnlineChatModule
+            self.chat_module = self._init_local_model()
+            print(f"成功加载模型")
+        except Exception as e:
+            print(f"无法初始化模型: {e}")
+            try:
+                # 如果模型加载失败，尝试在线模型
+                self.chat_module = OnlineChatModule()
+                print("成功加载在线模型")
+            except Exception as e2:
+                print(f"无法初始化在线模型: {e2}")
+                print("请设置API密钥，例如：export OPENAI_API_KEY=your_key")
+                # 使用模拟的聊天模块作为后备
+                self.chat_module = self._create_mock_chat_module()
+                print("使用模拟聊天模块作为后备方案")
+        
+        # 母婴产品类别数据
+        self.product_categories = {
+            "喂养用品": {
+                "subcategories": ["奶瓶", "奶嘴", "奶粉盒", "吸奶器", "辅食机", "餐具", "水杯"],
+                "features": ["安全性", "材质", "易用性", "清洁方便"]
+            },
+            "护理用品": {
+                "subcategories": ["纸尿裤", "湿纸巾", "爽身粉", "护臀膏", "沐浴露", "洗发水", "体温计"],
+                "features": ["温和性", "吸收性", "无刺激", "安全性"]
+            },
+            "服装服饰": {
+                "subcategories": ["婴儿服", "童装", "睡袋", "帽子", "袜子", "鞋子", "围兜"],
+                "features": ["舒适性", "透气性", "材质", "设计感"]
+            },
+            "安全座椅": {
+                "subcategories": ["提篮式座椅", "双向安全座椅", "增高垫", "汽车安全座椅"],
+                "features": ["安全性", "安装方便", "舒适性", "耐用性"]
+            },
+            "玩具教具": {
+                "subcategories": ["益智玩具", "毛绒玩具", "积木", "绘本", "音乐玩具", "运动玩具"],
+                "features": ["安全性", "教育性", "趣味性", "材质"]
+            },
+            "出行用品": {
+                "subcategories": ["婴儿车", "背带", "腰凳", "妈咪包", "折叠椅", "遮阳伞"],
+                "features": ["便携性", "舒适性", "耐用性", "多功能"]
+            },
+            "寝具用品": {
+                "subcategories": ["婴儿床", "床垫", "床上用品", "枕头", "被子", "蚊帐"],
+                "features": ["舒适性", "透气性", "安全性", "耐用性"]
+            }
+        }
+        
+        # 目标市场数据
+        self.target_markets = {
+            "北美": {
+                "countries": ["美国", "加拿大"],
+                "preferences": ["高品质", "安全认证", "有机材料", "创新功能"],
+                "price_sensitivity": "中低",
+                "logistics_cost_factor": 1.2
+            },
+            "欧洲": {
+                "countries": ["德国", "英国", "法国", "意大利", "西班牙"],
+                "preferences": ["环保认证", "安全标准", "有机材料", "设计感"],
+                "price_sensitivity": "中",
+                "logistics_cost_factor": 1.3
+            },
+            "东南亚": {
+                "countries": ["新加坡", "马来西亚", "泰国", "越南", "菲律宾"],
+                "preferences": ["性价比", "耐用性", "多功能", "本地化适配"],
+                "price_sensitivity": "高",
+                "logistics_cost_factor": 0.8
+            },
+            "中东": {
+                "countries": ["阿联酋", "沙特阿拉伯", "卡塔尔"],
+                "preferences": ["高品质", "豪华设计", "品牌认知", "大尺寸"],
+                "price_sensitivity": "低",
+                "logistics_cost_factor": 1.5
+            }
+        }
+        
+        # 构建选品流程
+        self.selection_pipeline = self._build_selection_pipeline()
+        
+        # 构建对话流程
+        self.chat_pipeline = self._build_chat_pipeline()
+    
+    def _init_local_model(self):
+        """初始化本地模型"""
+        try:
+            # 尝试从环境变量获取API密钥
+            api_key = os.environ.get("DOUBAO_API_KEY") or os.environ.get("LAZYLLM_DOUBAO_API_KEY") or os.environ.get("OPENAI_API_KEY")
+            if api_key:
+                print("检测到环境变量中的API密钥，使用在线模型")
+                try:
+                    # 优先尝试豆包模型
+                    if os.environ.get("DOUBAO_API_KEY") or os.environ.get("LAZYLLM_DOUBAO_API_KEY"):
+                        model = OnlineChatModule(
+                            source="doubao",
+                            api_key=api_key
+                        )
+                    else:
+                        # 如果没有豆包密钥但有OpenAI密钥，尝试OpenAI
+                        model = OnlineChatModule(
+                            source="openai",
+                            api_key=api_key
+                        )
+                    
+                    # 测试API密钥是否有效
+                    try:
+                        test_response = model("测试")
+                        print("API密钥验证成功，使用在线模型")
+                        return model
+                    except Exception as test_error:
+                        print(f"API密钥验证失败: {str(test_error)}")
+                        print("将尝试其他模型选项")
+                        # 继续尝试其他选项
+                except Exception as api_error:
+                    print(f"使用API密钥初始化在线模型失败: {str(api_error)}")
+                    print("将尝试其他模型选项")
+                    # 继续尝试其他选项
+            
+            # 尝试加载本地模型
+            local_model_path = os.environ.get("LOCAL_MODEL_PATH")
+            if local_model_path:
+                if os.path.exists(local_model_path):
+                    print(f"尝试加载本地模型: {local_model_path}")
+                    try:
+                        model = TrainableModule(local_model_path)
+                        # 尝试启动模型
+                        try:
+                            model.start()
+                            print("本地模型启动成功")
+                        except Exception as start_error:
+                            print(f"本地模型启动失败: {str(start_error)}")
+                            print("将尝试使用在线模型作为后备")
+                            raise start_error
+                        return model
+                    except Exception as e:
+                        print(f"加载本地模型失败: {str(e)}")
+                else:
+                    print(f"本地模型路径不存在: {local_model_path}")
+            
+            # 尝试使用常见的本地模型路径
+            common_model_paths = [
+                os.path.expanduser("~/.cache/huggingface/hub"),
+                "/models",
+                "./models"
+            ]
+            
+            for path in common_model_paths:
+                if os.path.exists(path):
+                    print(f"尝试从常见路径加载模型: {path}")
+                    try:
+                        # 尝试列出目录中的模型
+                        model_dirs = [d for d in os.listdir(path) 
+                                    if os.path.isdir(os.path.join(path, d))]
+                        if model_dirs:
+                            # 尝试第一个模型目录
+                            model_path = os.path.join(path, model_dirs[0])
+                            print(f"找到模型目录: {model_path}")
+                            model = TrainableModule(model_path)
+                            # 尝试启动模型
+                            try:
+                                model.start()
+                                print("本地模型启动成功")
+                                return model
+                            except Exception as start_error:
+                                print(f"本地模型启动失败: {str(start_error)}")
+                                print("将尝试下一个模型或在线模型")
+                                continue
+                    except Exception as e:
+                        print(f"从常见路径加载模型失败: {str(e)}")
+                        continue
+            
+            # 尝试使用在线模型
+            print("尝试使用在线模型...")
+            try:
+                model = OnlineChatModule(source="doubao")
+                # 测试模型是否可用
+                try:
+                    test_response = model("测试")
+                    print("在线模型验证成功")
+                    return model
+                except Exception as test_error:
+                    print(f"在线模型验证失败: {str(test_error)}")
+                    # 使用模拟聊天模块作为后备
+                    print("使用模拟聊天模块作为后备")
+                    model = self._create_mock_chat_module()
+                    return model
+            except Exception as online_error:
+                print(f"在线模型初始化失败: {str(online_error)}")
+                # 使用模拟聊天模块作为后备
+                print("使用模拟聊天模块作为后备")
+                model = self._create_mock_chat_module()
+                return model
+        except Exception as e:
+            print(f"初始化模型失败: {str(e)}")
+            # 使用模拟聊天模块作为后备
+            print("使用模拟聊天模块作为后备")
+            model = self._create_mock_chat_module()
+            return model
+    
+    def _create_mock_chat_module(self):
+        """创建模拟聊天模块作为后备方案"""
+        class MockChatModule:
+            def __call__(self, prompt):
+                # 简单的模拟响应，专注于母婴选品场景
+                if "选品" in prompt or "推荐" in prompt:
+                    return "我是跨境母婴类选品智能助手，我可以为您提供专业的母婴产品选品建议。请告诉我您感兴趣的产品类别和目标市场。"
+                elif "喂养用品" in prompt:
+                    return "喂养用品是母婴产品中的重要类别，包括奶瓶、奶嘴、吸奶器、辅食机等。建议选择符合安全标准、易于清洁的产品。"
+                elif "护理用品" in prompt:
+                    return "护理用品包括纸尿裤、湿纸巾、护臀膏等。建议选择温和无刺激、吸收性好的产品，特别要注意材质的安全性。"
+                elif "安全座椅" in prompt:
+                    return "安全座椅是保障婴儿出行安全的重要产品。建议选择通过权威安全认证、安装方便、舒适性好的产品。"
+                elif "玩具" in prompt:
+                    return "玩具不仅能给孩子带来乐趣，还能促进智力发展。建议选择安全无毒、适合孩子年龄、具有教育意义的玩具。"
+                elif "目标市场" in prompt:
+                    return "不同的目标市场有不同的消费偏好。北美市场注重高品质和安全认证，欧洲市场注重环保和设计感，东南亚市场注重性价比。"
+                else:
+                    return "您好！我是跨境母婴类选品智能助手，很高兴为您服务。我可以为您提供母婴产品的选品建议、市场分析和趋势预测。请告诉我您需要什么帮助。"
+        
+        return MockChatModule()
+    
+    def _build_selection_pipeline(self):
+        """构建母婴产品选品流程"""
+        
+        def market_analysis(user_input):
+            """市场分析：根据用户需求分析目标市场和产品类别"""
+            # 提取目标市场
+            target_market = None
+            for market in self.target_markets:
+                if market in user_input:
+                    target_market = market
+                    break
+            
+            # 如果没有指定市场，默认为北美
+            if not target_market:
+                target_market = "北美"
+            
+            # 提取产品类别
+            product_category = None
+            for category in self.product_categories:
+                if category in user_input:
+                    product_category = category
+                    break
+            
+            # 如果没有指定类别，使用大模型分析
+            if not product_category:
+                prompt = f"""
+                根据用户需求"{user_input}"，从以下母婴产品类别中选择最合适的一个：
+                {list(self.product_categories.keys())}
+                
+                只回答类别名称，不需要解释。
+                """
+                product_category = self.chat_module(prompt).strip()
+                if product_category not in self.product_categories:
+                    product_category = "喂养用品"  # 默认类别
+            
+            return {
+                "target_market": target_market,
+                "product_category": product_category,
+                "market_info": self.target_markets[target_market],
+                "category_info": self.product_categories[product_category]
+            }
+        
+        def product_research(analysis_result):
+            """产品研究：基于市场和类别研究热门产品"""
+            target_market = analysis_result["target_market"]
+            product_category = analysis_result["product_category"]
+            
+            # 构建产品研究提示
+            prompt = f"""
+            作为跨境电商母婴选品专家，请为{target_market}市场研究5款热门的{product_category}产品。
+            
+            要求：
+            1. 每款产品包含：产品名称、主要特点、目标客户群体、价格区间（美元）
+            2. 考虑{target_market}市场的消费者偏好：{', '.join(analysis_result['market_info']['preferences'])} 
+            3. 考虑价格敏感度：{analysis_result['market_info']['price_sensitivity']}
+            4. 产品应符合母婴产品的安全标准和质量要求
+            5. 以JSON格式返回，包含products数组，每个产品包含name, features, target_audience, price_range字段
+            
+            示例格式：
+            {{
+                "products": [
+                    {{
+                        "name": "产品名称",
+                        "features": ["特点1", "特点2"],
+                        "target_audience": "目标客户群体",
+                        "price_range": {{
+                            "min": 10,
+                            "max": 50
+                        }}
+                    }}
+                ]
+            }}
+            """
+            
+            try:
+                response = self.chat_module(prompt)
+                # 尝试解析JSON
+                if "```json" in response:
+                    json_str = response.split("```json")[1].split("```")[0].strip()
+                else:
+                    # 尝试提取JSON部分
+                    json_match = re.search(r'\{.*\}', response, re.DOTALL)
+                    json_str = json_match.group(0) if json_match else response
+                
+                product_data = json.loads(json_str)
+                return {{
+                    **analysis_result,
+                    "researched_products": product_data.get("products", [])
+                }}
+            except Exception as e:
+                print(f"解析产品研究数据失败: {e}")
+                # 返回默认产品数据
+                default_products = [
+                    {{
+                        "name": f"智能{product_category}A",
+                        "features": ["安全材质", "易用性", "高品质"],
+                        "target_audience": "新手父母",
+                        "price_range": {{"min": 20, "max": 60}}
+                   }},
+                    {{
+                        "name": f"便携{product_category}B",
+                        "features": ["轻便易携带", "多功能", "性价比高"],
+                        "target_audience": "经常外出的父母",
+                        "price_range": {{"min": 15, "max": 40}}
+                   }}
+                ]
+                
+                return {{
+                    **analysis_result,
+                    "researched_products": default_products
+                }}
+        
+        def supplier_analysis(research_result):
+            """供应商分析：分析潜在供应商和成本结构"""
+            products = research_result["researched_products"]
+            target_market = research_result["target_market"]
+            logistics_factor = research_result["market_info"]["logistics_cost_factor"]
+            
+            analyzed_products = []
+            
+            for product in products:
+                # 构建供应商分析提示
+                prompt = f"""
+                作为供应链专家，请分析"{product['name']}"的供应商情况：
+                
+                1. 估算生产成本（基于产品特点和价格区间）
+                2. 估算物流成本（考虑{target_market}市场，物流系数{logistics_factor}）
+                3. 估算关税和税费
+                4. 识别潜在供应链风险
+                5. 推荐供应商类型（工厂、贸易公司等）
+                
+                以JSON格式返回，包含production_cost, logistics_cost, tariffs, risks, supplier_type字段
+                """
+                
+                try:
+                    response = self.chat_module(prompt)
+                    # 尝试解析JSON
+                    if "```json" in response:
+                        json_str = response.split("```json")[1].split("```")[0].strip()
+                    else:
+                        # 尝试提取JSON部分
+                        json_match = re.search(r'\{.*\}', response, re.DOTALL)
+                        json_str = json_match.group(0) if json_match else response
+                    
+                    analysis_data = json.loads(json_str)
+                except Exception as e:
+                    print(f"解析供应商分析数据失败: {e}")
+                    # 返回默认分析数据
+                    price_mid = (product["price_range"]["min"] + product["price_range"]["max"]) / 2
+                    analysis_data = {
+                        "production_cost": price_mid * 0.3,
+                        "logistics_cost": price_mid * 0.1 * logistics_factor,
+                        "tariffs": price_mid * 0.05,
+                        "risks": ["供应链不稳定", "质量波动"],
+                        "supplier_type": "工厂直销"
+                    }
+                
+                # 计算利润率
+                try:
+                    prod_cost = analysis_data.get("production_cost", 0)
+                    if isinstance(prod_cost, dict):
+                        min_val = prod_cost.get("min", 0)
+                        max_val = prod_cost.get("max", 0)
+                        prod_cost = float(min_val) if min_val else float(max_val)
+                    production_cost = float(prod_cost)
+                except (ValueError, TypeError):
+                    production_cost = 0
+                
+                try:
+                    log_cost = analysis_data.get("logistics_cost", 0)
+                    if isinstance(log_cost, dict):
+                        min_val = log_cost.get("min", 0)
+                        max_val = log_cost.get("max", 0)
+                        log_cost = float(min_val) if min_val else float(max_val)
+                    logistics_cost = float(log_cost)
+                except (ValueError, TypeError):
+                    logistics_cost = 0
+                
+                try:
+                    tariff_cost = analysis_data.get("tariffs", 0)
+                    if isinstance(tariff_cost, dict):
+                        percentage = tariff_cost.get("percentage", 0)
+                        min_val = tariff_cost.get("min", 0)
+                        max_val = tariff_cost.get("max", 0)
+                        if percentage:
+                            tariff_cost = float(percentage)
+                        else:
+                            tariff_cost = float(min_val) if min_val else float(max_val)
+                    tariffs = float(tariff_cost)
+                except (ValueError, TypeError):
+                    tariffs = 0
+                
+                total_cost = production_cost + logistics_cost + tariffs
+                avg_price = (product["price_range"]["min"] + product["price_range"]["max"]) / 2
+                profit_margin = (avg_price - total_cost) / avg_price * 100
+                
+                analyzed_products.append({
+                    **product,
+                    "cost_analysis": analysis_data,
+                    "total_cost": total_cost,
+                    "average_price": avg_price,
+                    "profit_margin": profit_margin
+                })
+            
+            return {
+                **research_result,
+                "analyzed_products": analyzed_products
+            }
+        
+        def competition_analysis(analysis_result):
+            """竞争分析：分析市场竞争格局和差异化机会"""
+            products = analysis_result["analyzed_products"]
+            target_market = analysis_result["target_market"]
+            product_category = analysis_result["product_category"]
+            
+            competition_results = []
+            
+            for product in products:
+                # 构建竞争分析提示
+                prompt = f"""
+                作为市场分析师，请分析"{product['name']}"在{target_market}{product_category}市场的竞争情况：
+                
+                1. 识别主要竞争对手（2-3个）
+                2. 分析竞争对手定价策略
+                3. 识别市场空白和差异化机会
+                4. 评估市场进入难度
+                5. 提供差异化建议
+                
+                以JSON格式返回，包含competitors, pricing_strategy, market_gaps, entry_difficulty, differentiation字段
+                """
+                
+                try:
+                    response = self.chat_module(prompt)
+                    # 尝试解析JSON
+                    if "```json" in response:
+                        json_str = response.split("```json")[1].split("```")[0].strip()
+                    else:
+                        # 尝试提取JSON部分
+                        json_match = re.search(r'\{.*\}', response, re.DOTALL)
+                        json_str = json_match.group(0) if json_match else response
+                    
+                    competition_data = json.loads(json_str)
+                except Exception as e:
+                    print(f"解析竞争分析数据失败: {e}")
+                    # 返回默认分析数据
+                    competition_data = {
+                        "competitors": ["品牌A", "品牌B"],
+                        "pricing_strategy": "中高端定价",
+                        "market_gaps": ["有机材料", "个性化定制"],
+                        "entry_difficulty": "中等",
+                        "differentiation": ["创新设计", "优质材料"]
+                    }
+                
+                competition_results.append({
+                    **product,
+                    "competition_analysis": competition_data
+                })
+            
+            return {
+                **analysis_result,
+                "competition_results": competition_results
+            }
+        
+        def generate_recommendation(competition_result):
+            """生成最终推荐：基于所有分析生成选品推荐"""
+            products = competition_result["competition_results"]
+            target_market = competition_result["target_market"]
+            product_category = competition_result["product_category"]
+            
+            # 按利润率排序
+            sorted_products = sorted(products, key=lambda x: x["profit_margin"], reverse=True)
+            
+            # 构建推荐提示
+            top_products = sorted_products[:3]  # 取前3个产品
+            products_summary = "\n".join([
+                f"{i+1}. {p['name']}: 利润率{p['profit_margin']:.1f}%, 市场差异化: {', '.join(p['competition_analysis'].get('differentiation', ['无差异化信息']))}"
+                for i, p in enumerate(top_products)
+            ])
+            
+            prompt = f"""
+            基于以下分析结果，为{target_market}{product_category}市场提供选品建议：
+            
+            产品分析结果：
+            {products_summary}
+            
+            请提供：
+            1. 最推荐的产品及理由
+            2. 市场进入策略
+            3. 风险控制建议
+            4. 长期发展规划
+            
+            以专业、简洁的顾问口吻回答，突出关键建议。
+            """
+            
+            recommendation = self.chat_module(prompt)
+            
+            return {
+                "market": target_market,
+                "category": product_category,
+                "top_recommendations": sorted_products[:3],
+                "detailed_recommendation": recommendation,
+                "generation_time": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            }
+        
+        # 构建流程管道 - 使用自定义函数替代pipeline，避免字典哈希错误
+        def selection_pipeline(user_input):
+            # 依次执行各个分析步骤
+            market_result = market_analysis(user_input)
+            research_result = product_research(market_result)
+            supplier_result = supplier_analysis(research_result)
+            competition_result = competition_analysis(supplier_result)
+            final_result = generate_recommendation(competition_result)
+            return final_result
+        
+        return selection_pipeline
+    
+    def _build_chat_pipeline(self):
+        """构建对话流程"""
+        
+        def intent_recognition(user_input):
+            """意图识别：识别用户意图是选品咨询还是其他问题"""
+            prompt = f"""
+            请识别用户意图："用户说：{user_input}"
+            
+            意图类型：
+            1. 选品咨询 - 用户想要获取产品选品建议
+            2. 市场咨询 - 用户想了解市场情况
+            3. 产品咨询 - 用户想了解特定产品信息
+            4. 其他 - 其他类型问题
+            
+            只回答意图类型编号（1-4），不需要解释。
+            """
+            
+            try:
+                intent = self.chat_module(prompt).strip()
+                intent_map = {
+                    "1": "选品咨询",
+                    "2": "市场咨询",
+                    "3": "产品咨询",
+                    "4": "其他"
+                }
+                return intent_map.get(intent, "其他")
+            except:
+                return "其他"
+        
+        def response_generation(user_input, intent):
+            """根据意图生成回复"""
+            if intent == "选品咨询":
+                # 调用选品流程
+                try:
+                    result = self.selection_pipeline(user_input)
+                    return self._format_selection_result(result)
+                except Exception as e:
+                    return f"选品分析过程中出现错误：{str(e)}。请尝试重新描述您的需求。"
+            
+            elif intent == "市场咨询":
+                prompt = f"""
+                作为跨境电商母婴市场专家，请回答以下市场咨询问题：
+                用户问题：{user_input}
+                
+                请提供专业、简洁的回答，重点关注北美、欧洲和东南亚市场的母婴产品趋势。
+                """
+                return self.chat_module(prompt)
+            
+            elif intent == "产品咨询":
+                prompt = f"""
+                作为母婴产品专家，请回答以下产品咨询问题：
+                用户问题：{user_input}
+                
+                请提供专业、准确的回答，重点关注产品的安全性、质量标准和使用建议。
+                """
+                return self.chat_module(prompt)
+            
+            else:
+                # 其他类型问题，直接使用聊天模块
+                prompt = f"""
+                作为跨境母婴类选品智能助手，请回答用户的问题：
+                用户问题：{user_input}
+                
+                请提供友好、专业的回答，重点关注母婴产品相关的内容。
+                """
+                return self.chat_module(prompt)
+        
+        def chat_pipeline(input_data):
+            """整合对话流程"""
+            user_input = input_data.get("user_input", "")
+            
+            # 识别用户意图
+            intent = intent_recognition(user_input)
+            
+            # 生成响应
+            response = response_generation(user_input, intent)
+            
+            return {
+                "response": response
+            }
+        
+        return chat_pipeline
+    
+    def _format_selection_result(self, result):
+        """格式化选品结果"""
+        if "error" in result:
+            return f"选品分析过程中出现错误：{result['error']}"
+        
+        # 构建格式化的响应
+        response = f"# 跨境母婴类选品建议\n\n"
+        response += f"## 市场与类别分析\n"
+        response += f"- 目标市场：{result['market']}\n"
+        response += f"- 产品类别：{result['category']}\n\n"
+        
+        response += f"## 热门产品推荐\n"
+        for i, product in enumerate(result['top_recommendations'], 1):
+            response += f"### {i}. {product['name']}\n"
+            response += f"- **主要特点**：{', '.join(product['features'])}\n"
+            response += f"- **目标客户群体**：{product['target_audience']}\n"
+            response += f"- **价格区间**：${product['price_range']['min']} - ${product['price_range']['max']}\n"
+            response += f"- **利润率**：{product['profit_margin']:.1f}%\n\n"
+        
+        response += f"## 详细选品建议\n"
+        response += result['detailed_recommendation']
+        response += f"\n\n---\n"
+        response += f"生成时间：{result['generation_time']}\n"
+        response += f"如果您需要更详细的产品分析或市场调研，请随时告诉我！"
+        
+        return response
+    
+    def chat(self, user_input):
+        """与用户进行对话"""
+        try:
+            result = self.chat_pipeline({"user_input": user_input})
+            return result.get("response", "抱歉，我无法理解您的请求。")
+        except Exception as e:
+            print(f"对话处理失败: {e}")
+            return "抱歉，我在处理您的请求时遇到了问题。"
+    
+    def get_product_categories(self):
+        """获取产品类别信息"""
+        return self.product_categories
+    
+    def get_target_markets(self):
+        """获取目标市场信息"""
+        return self.target_markets
+
+# 测试代码
+if __name__ == "__main__":
+    agent = CrossBorderMaternalAgent()
+    print("跨境母婴类选品智能助手已启动！")
+    print("您可以输入问题或需求，输入'quit'退出。")
+    
+    while True:
+        user_input = input("用户: ")
+        if user_input.lower() == "quit":
+            print("再见！")
+            break
+        
+        response = agent.chat(user_input)
+        print(f"助手: {response}")
\ No newline at end of file
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d119c62c7522e0e936a557648ba201ed390b67cc
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,18 @@
+lazyllm>=0.1.0
+transformers>=4.30.0
+pydantic>=2.0.0
+requests>=2.31.0
+pandas>=2.0.0
+flask>=2.0.0
+numpy>=1.24.0
+matplotlib>=3.7.0
+openai>=1.0.0  # 用于真实API调用
+tiktoken>=0.5.0  # 用于token计算
+aiohttp>=3.8.0  # 用于异步HTTP请求
+asyncio  # 用于异步处理
+torch>=2.0.0  # 本地模型所需
+accelerate>=0.20.0  # 本地模型加速
+sentencepiece>=0.1.99  # 本地模型分词
+protobuf>=3.20.0  # 本地模型依赖
+scipy>=1.10.0  # 本地模型依赖
+modelscope>=1.30.0  # 本地模型下载和管理
\ No newline at end of file
diff --git a/web_agent.py b/web_agent.py
new file mode 100644
index 0000000000000000000000000000000000000000..d25b48ff9120563b2e6d8adaa967ce37e6ceee57
--- /dev/null
+++ b/web_agent.py
@@ -0,0 +1,580 @@
+from flask import Flask, render_template_string, request, jsonify
+from maternal_agent import MaternalAgent
+
+# 初始化Flask应用
+app = Flask(__name__)
+
+# 初始化母婴选品Agent
+agent = MaternalAgent()
+
+# HTML模板
+html_template = '''
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>跨境母婴用品-智选Agent</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            background: linear-gradient(135deg, #ff6a9e 0%, #ff9a9e 100%);
+            min-height: 100vh;
+            padding: 20px;
+        }
+
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+        }
+
+        .header {
+            text-align: center;
+            color: white;
+            margin-bottom: 40px;
+        }
+
+        .header h1 {
+            font-size: 2.5em;
+            margin-bottom: 10px;
+            text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
+        }
+
+        .header p {
+            font-size: 1.2em;
+            opacity: 0.9;
+        }
+
+        .main-content {
+            margin-bottom: 30px;
+        }
+
+        .panel {
+            background: white;
+            border-radius: 15px;
+            padding: 30px;
+            box-shadow: 0 10px 30px rgba(0,0,0,0.2);
+        }
+
+        .panel h2 {
+            font-size: 1.5em;
+            margin-bottom: 20px;
+            color: #333;
+            border-bottom: 3px solid #667eea;
+            padding-bottom: 10px;
+        }
+
+        .form-group {
+            margin-bottom: 20px;
+        }
+
+        .form-group label {
+            display: block;
+            margin-bottom: 8px;
+            font-weight: 600;
+            color: #555;
+        }
+
+        .form-group select,
+        .form-group input {
+            width: 100%;
+            padding: 12px;
+            border: 2px solid #e1e5e9;
+            border-radius: 8px;
+            font-size: 16px;
+            transition: border-color 0.3s;
+        }
+
+        .form-group select:focus,
+        .form-group input:focus {
+            outline: none;
+            border-color: #667eea;
+        }
+
+
+
+        .chat-container {
+            display: flex;
+            flex-direction: column;
+            height: 600px;
+        }
+
+        .chat-header {
+            display: flex;
+            align-items: center;
+            margin-bottom: 20px;
+        }
+
+        .agent-avatar {
+            font-size: 2.5em;
+            margin-right: 15px;
+        }
+
+        .chat-header h2 {
+            font-size: 1.8em;
+            margin: 0;
+            border: none;
+            padding: 0;
+        }
+
+        .chat-messages {
+            flex: 1;
+            overflow-y: auto;
+            border: 2px solid #ff9a9e;
+            border-radius: 10px;
+            padding: 20px;
+            margin-bottom: 20px;
+            background: #fff5f7;
+        }
+
+        .message {
+            margin-bottom: 20px;
+            display: flex;
+            max-width: 80%;
+        }
+
+        .message.user {
+            margin-left: auto;
+            justify-content: flex-end;
+        }
+
+        .message.agent {
+            margin-right: auto;
+            justify-content: flex-start;
+        }
+
+        .message-bubble {
+            padding: 15px 20px;
+            border-radius: 20px;
+            word-wrap: break-word;
+            line-height: 1.5;
+        }
+
+        .message.user .message-bubble {
+            background: linear-gradient(135deg, #ff9a9e 0%, #fecfef 100%);
+            color: white;
+            border-bottom-right-radius: 5px;
+        }
+
+        .message.agent .message-bubble {
+            background: white;
+            color: #333;
+            border-bottom-left-radius: 5px;
+            box-shadow: 0 2px 5px rgba(0,0,0,0.1);
+        }
+
+        .message-info {
+            font-size: 0.8em;
+            color: #999;
+            margin: 0 10px;
+            align-self: flex-end;
+        }
+
+        .chat-input-container {
+            display: flex;
+            gap: 10px;
+        }
+
+        .chat-input {
+            flex: 1;
+            padding: 12px 20px;
+            border: 2px solid #ff9a9e;
+            border-radius: 25px;
+            font-size: 16px;
+        }
+
+        .send-button {
+            padding: 12px 30px;
+            background: linear-gradient(135deg, #ff9a9e 0%, #fecfef 100%);
+            color: white;
+            border: none;
+            border-radius: 25px;
+            font-size: 16px;
+            font-weight: 600;
+            cursor: pointer;
+            transition: transform 0.2s;
+        }
+
+        .send-button:hover {
+            transform: translateY(-2px);
+        }
+
+        .suggested-questions {
+            background: white;
+            border-radius: 15px;
+            padding: 30px;
+            box-shadow: 0 10px 30px rgba(0,0,0,0.2);
+        }
+
+        .suggested-questions h3 {
+            font-size: 1.3em;
+            margin-bottom: 20px;
+            color: #333;
+        }
+
+        .question-tags {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 10px;
+        }
+
+        .question-tag {
+            padding: 10px 18px;
+            background: #fff5f7;
+            border: 2px solid #ff9a9e;
+            border-radius: 20px;
+            cursor: pointer;
+            transition: all 0.3s;
+            font-size: 14px;
+        }
+
+        .question-tag:hover {
+            background: linear-gradient(135deg, #ff9a9e 0%, #fecfef 100%);
+            color: white;
+            border-color: transparent;
+            transform: translateY(-2px);
+        }
+
+        /* 思考动画样式 */
+        .thinking-container {
+            display: flex;
+            align-items: center;
+        }
+
+        .thinking-dots {
+            display: flex;
+            gap: 4px;
+        }
+
+        .thinking-dot {
+            width: 8px;
+            height: 8px;
+            background: #ff9a9e;
+            border-radius: 50%;
+            animation: thinking 1.4s infinite;
+        }
+
+        .thinking-dot:nth-child(2) {
+            animation-delay: 0.2s;
+        }
+
+        .thinking-dot:nth-child(3) {
+            animation-delay: 0.4s;
+        }
+
+        @keyframes thinking {
+            0%, 80%, 100% {
+                transform: scale(0);
+            }
+            40% {
+                transform: scale(1);
+            }
+        }
+
+        /* 响应式设计 */
+        @media (max-width: 968px) {
+            .main-content {
+                grid-template-columns: 1fr;
+            }
+
+            .chat-container {
+                height: 500px;
+            }
+
+            .message {
+                max-width: 90%;
+            }
+        }
+
+        @media (max-width: 640px) {
+            .header h1 {
+                font-size: 2em;
+            }
+
+            .panel {
+                padding: 20px;
+            }
+
+            .chat-messages {
+                padding: 15px;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>🤱 跨境跨境母婴用品-智选Agent</h1>
+            <p>专业的母婴产品选品建议、市场分析和趋势预测</p>
+        </div>
+
+        <div class="main-content">
+            <div class="chat-container">
+                
+                <div class="chat-messages" id="chatMessages">
+                    <div class="message agent">
+                        <div class="message-bubble">
+                            您好！我是跨境母婴类选品智能助手，很高兴为您服务。我可以为您提供母婴产品的选品建议、市场分析和趋势预测。请告诉我您需要什么帮助？
+                        </div>
+                        <div class="message-info">刚刚</div>
+                    </div>
+                </div>
+                
+                <div class="chat-input-container">
+                    <input type="text" class="chat-input" id="chatInput" placeholder="请输入您的问题或需求..." />
+                    <button class="send-button" id="sendButton">发送</button>
+                </div>
+            </div>
+        </div>
+        
+        <div class="suggested-questions">
+            <h3>💡 建议的问题</h3>
+            <div class="question-tags">
+                <span class="question-tag" onclick="sendQuestion('推荐一些适合北美市场的喂养用品')">推荐一些适合北美市场的喂养用品</span>
+                <span class="question-tag" onclick="sendQuestion('欧洲市场对母婴护理用品有什么偏好')">欧洲市场对母婴护理用品有什么偏好</span>
+                <span class="question-tag" onclick="sendQuestion('东南亚市场的安全座椅需求如何')">东南亚市场的安全座椅需求如何</span>
+                <span class="question-tag" onclick="sendQuestion('中东市场适合销售哪些母婴产品')">中东市场适合销售哪些母婴产品</span>
+                <span class="question-tag" onclick="sendQuestion('婴儿玩具的选品要点有哪些')">婴儿玩具的选品要点有哪些</span>
+                <span class="question-tag" onclick="sendQuestion('母婴产品的跨境物流建议')">母婴产品的跨境物流建议</span>
+            </div>
+        </div>
+    </div>
+    
+    <script>
+        // 获取DOM元素
+        const chatMessages = document.getElementById('chatMessages');
+        const chatInput = document.getElementById('chatInput');
+        const sendButton = document.getElementById('sendButton');
+        
+        // 发送建议问题函数（提前定义，确保在页面加载时可用）
+        function sendQuestion(question) {
+            chatInput.value = question;
+            sendMessage();
+        }
+        
+        // 发送消息函数
+        function sendMessage() {
+            const message = chatInput.value.trim();
+            if (message === '') return;
+            
+            // 添加用户消息到聊天界面
+            addMessageToChat(message, 'user');
+            
+            // 清空输入框
+            chatInput.value = '';
+            
+            // 显示思考动画
+            const thinkingMessageId = showThinkingAnimation();
+            
+            // 调用API获取助手响应
+            fetch('/chat', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ message: message }),
+            })
+            .then(response => response.json())
+            .then(data => {
+                // 隐藏思考动画并显示实际响应
+                hideThinkingAnimation(thinkingMessageId);
+                if (data.response) {
+                    addRichTextMessageToChat(data.response, 'agent');
+                }
+            })
+            .catch(error => {
+                console.error('Error:', error);
+                // 隐藏思考动画并显示错误信息
+                hideThinkingAnimation(thinkingMessageId);
+                addRichTextMessageToChat('抱歉，我在处理您的请求时遇到了问题。', 'agent');
+            });
+        }
+        
+        // 添加消息到聊天界面
+        function addMessageToChat(message, type) {
+            const messageDiv = document.createElement('div');
+            messageDiv.className = 'message ' + type;
+            
+            const messageBubble = document.createElement('div');
+            messageBubble.className = 'message-bubble';
+            messageBubble.textContent = message;
+            
+            const messageInfo = document.createElement('div');
+            messageInfo.className = 'message-info';
+            messageInfo.textContent = new Date().toLocaleTimeString('zh-CN');
+            
+            messageDiv.appendChild(messageBubble);
+            messageDiv.appendChild(messageInfo);
+            
+            chatMessages.appendChild(messageDiv);
+            
+            // 滚动到最新消息
+            chatMessages.scrollTop = chatMessages.scrollHeight;
+        }
+        
+        // 添加富文本消息到聊天界面
+        function addRichTextMessageToChat(message, type) {
+            const messageDiv = document.createElement('div');
+            messageDiv.className = 'message ' + type;
+            
+            const messageBubble = document.createElement('div');
+            messageBubble.className = 'message-bubble';
+            
+            // 将Markdown转换为富文本
+            messageBubble.innerHTML = markdownToHtml(message);
+            
+            const messageInfo = document.createElement('div');
+            messageInfo.className = 'message-info';
+            messageInfo.textContent = new Date().toLocaleTimeString('zh-CN');
+            
+            messageDiv.appendChild(messageBubble);
+            messageDiv.appendChild(messageInfo);
+            
+            chatMessages.appendChild(messageDiv);
+            
+            // 滚动到最新消息
+            chatMessages.scrollTop = chatMessages.scrollHeight;
+        }
+        
+        // Markdown转HTML函数（增强版）
+        function markdownToHtml(markdown) {
+            let html = markdown;
+            
+            // 标题：# H1, ## H2, ### H3
+            html = html.replace(/^(#{1,6})\s+(.*)$/gm, function(match, hashes, text) {
+                const level = hashes.length;
+                return `<h${level}>${text}</h${level}>`;
+            });
+            
+            // 无序列表：- 或 * 开头
+            html = html.replace(/^[\*\-]\s+(.*)$/gm, '<li>$1</li>');
+            html = html.replace(/(<li>.*<\/li>)/s, '<ul>$1</ul>');
+            
+            // 有序列表：数字. 开头
+            html = html.replace(/^\d+\.\s+(.*)$/gm, '<li>$1</li>');
+            html = html.replace(/(<li>.*<\/li>)/s, '<ol>$1</ol>');
+            
+            // 加粗：**text**
+            while (html.indexOf('**') !== -1) {
+                html = html.replace('**', '<strong>', 1).replace('**', '</strong>', 1);
+            }
+            
+            // 斜体：*text*
+            while (html.indexOf('*') !== -1) {
+                html = html.replace('*', '<em>', 1).replace('*', '</em>', 1);
+            }
+            
+            // 链接：[text](url)
+            html = html.replace(/\[(.*?)\]\((.*?)\)/g, '<a href="$2" target="_blank">$1</a>');
+            
+            // 行内代码：`code`
+            html = html.replace(/`(.*?)`/g, '<code>$1</code>');
+            
+            // 代码块：```language
+            // code
+            // ```
+            html = html.replace(/```([\s\S]*?)```/g, '<pre><code>$1</code></pre>');
+            
+            // 换行
+            while (html.indexOf('\\n') !== -1) {
+                html = html.replace('\\n', '<br>', 1);
+            }
+            
+            return html;
+        }
+        
+        // 显示思考动画
+        function showThinkingAnimation() {
+            const messageDiv = document.createElement('div');
+            const messageId = 'thinking-' + Date.now();
+            messageDiv.id = messageId;
+            messageDiv.className = 'message agent';
+            
+            const messageBubble = document.createElement('div');
+            messageBubble.className = 'message-bubble';
+            
+            const thinkingContainer = document.createElement('div');
+            thinkingContainer.className = 'thinking-container';
+            
+            const thinkingText = document.createElement('span');
+            thinkingText.textContent = '正在思考中';
+            thinkingText.style.marginRight = '8px';
+            
+            const thinkingDots = document.createElement('div');
+            thinkingDots.className = 'thinking-dots';
+            
+            for (let i = 0; i < 3; i++) {
+                const dot = document.createElement('div');
+                dot.className = 'thinking-dot';
+                thinkingDots.appendChild(dot);
+            }
+            
+            thinkingContainer.appendChild(thinkingText);
+            thinkingContainer.appendChild(thinkingDots);
+            messageBubble.appendChild(thinkingContainer);
+            
+            const messageInfo = document.createElement('div');
+            messageInfo.className = 'message-info';
+            messageInfo.textContent = new Date().toLocaleTimeString('zh-CN');
+            
+            messageDiv.appendChild(messageBubble);
+            messageDiv.appendChild(messageInfo);
+            
+            chatMessages.appendChild(messageDiv);
+            chatMessages.scrollTop = chatMessages.scrollHeight;
+            
+            return messageId;
+        }
+        
+        // 隐藏思考动画
+        function hideThinkingAnimation(messageId) {
+            const thinkingElement = document.getElementById(messageId);
+            if (thinkingElement) {
+                thinkingElement.remove();
+            }
+        }
+        
+
+        
+        // 事件监听器
+        sendButton.addEventListener('click', sendMessage);
+        
+        chatInput.addEventListener('keypress', function(e) {
+            if (e.key === 'Enter') {
+                sendMessage();
+            }
+        });
+    </script>
+</body>
+</html>
+'''
+
+@app.route('/')
+def index():
+    return render_template_string(html_template)
+
+@app.route('/chat', methods=['POST'])
+def chat():
+    data = request.get_json()
+    message = data.get('message', '')
+    response = agent.chat(message)
+    return jsonify({'response': response})
+
+@app.route('/categories', methods=['GET'])
+def get_categories():
+    categories = agent.get_product_categories()
+    return jsonify(categories)
+
+@app.route('/markets', methods=['GET'])
+def get_markets():
+    markets = agent.get_target_markets()
+    return jsonify(markets)
+
+if __name__ == '__main__':
+    app.run(debug=True, host='0.0.0.0', port=5005)
diff --git "a/\346\212\200\346\234\257\346\226\207\346\241\243.md" "b/\346\212\200\346\234\257\346\226\207\346\241\243.md"
new file mode 100644
index 0000000000000000000000000000000000000000..681cf0b52ed79a6d775ddb37ba36f446c051c703
--- /dev/null
+++ "b/\346\212\200\346\234\257\346\226\207\346\241\243.md"
@@ -0,0 +1,294 @@
+# 跨境母婴用品-智选Agent技术文档
+
+## 1. 项目介绍
+
+跨境母婴用品-智选Agent，专为跨境电商卖家设计，旨在解决海外母婴产品选品难题。基于LazyLLM框架开发，集成了AI大语言模型能力，提供精准的选品建议、市场分析和趋势预测。支持北美、欧洲、东南亚、中东等多个海外市场，覆盖喂养用品、护理用品、服装服饰、安全座椅、玩具教具、出行用品、寝具用品等多个母婴产品类别，帮助卖家快速找到高潜力、高利润的产品，提升跨境电商业务的成功率和效率。
+
+## 2. 成员详情
+
+- 主要负责人：杨媛媛
+- 技术栈：LazyLLM框架、Flask Web框架、Python编程语言
+- 核心功能：AI模型集成、选品流程构建、市场数据分析、Web应用开发
+
+## 3. 技术栈
+
+
+| 技术/框架    | 版本要求 | 用途                       |
+| ------------ | -------- | -------------------------- |
+| LazyLLM      | >=0.1.0  | 构建智能对话和选品分析模块 |
+| Flask        | >=2.0.0  | 构建Web应用界面            |
+| Python       | 3.8+     | 编程语言                   |
+| Transformers | >=4.30.0 | 自然语言处理模型           |
+| Pydantic     | >=2.0.0  | 数据验证                   |
+| Requests     | >=2.31.0 | HTTP请求                   |
+| Pandas       | >=2.0.0  | 数据分析                   |
+| NumPy        | >=1.24.0 | 数值计算                   |
+| Matplotlib   | >=3.7.0  | 数据可视化                 |
+| OpenAI       | >=1.0.0  | 真实API调用                |
+| Torch        | >=2.0.0  | 本地模型支持               |
+| Accelerate   | >=0.20.0 | 本地模型加速               |
+
+## 4. 接口设计
+
+### 4.1 核心类接口
+
+#### MaternalAgent类
+
+```python
+class MaternalAgent:
+    def __init__(self):
+        """初始化MaternalAgent，加载模型和数据"""
+      
+    def _init_local_model(self):
+        """初始化本地模型"""
+      
+    def _create_mock_chat_module(self):
+        """创建模拟聊天模块作为后备"""
+      
+    def _build_selection_pipeline(self):
+        """构建选品流程"""
+      
+    def _build_chat_pipeline(self):
+        """构建对话流程"""
+      
+    def analyze_market(self, product_category, target_market):
+        """分析特定市场的产品需求和趋势"""
+      
+    def suggest_products(self, product_category, target_market, budget=None):
+        """根据产品类别和目标市场提供选品建议"""
+      
+    def evaluate_competition(self, product_name, target_market):
+        """评估产品在目标市场的竞争情况"""
+      
+    def calculate_profit_margin(self, product_cost, shipping_cost, target_price):
+        """计算产品的利润率"""
+      
+    def get_product_categories(self):
+        """获取所有产品类别"""
+      
+    def get_target_markets(self):
+        """获取所有目标市场"""
+```
+
+### 4.2 Web接口
+
+
+| 接口路径                  | 请求方法 | 参数                                      | 返回值         | 用途                               |
+| ------------------------- | -------- | ----------------------------------------- | -------------- | ---------------------------------- |
+| /api/analyze-market       | POST     | product_category, target_market           | 市场分析报告   | 分析特定市场的产品需求和趋势       |
+| /api/suggest-products     | POST     | product_category, target_market, budget   | 选品建议列表   | 根据产品类别和目标市场提供选品建议 |
+| /api/evaluate-competition | POST     | product_name, target_market               | 竞争分析报告   | 评估产品在目标市场的竞争情况       |
+| /api/calculate-profit     | POST     | product_cost, shipping_cost, target_price | 利润率计算结果 | 计算产品的利润率                   |
+| /api/product-categories   | GET      | 无                                        | 产品类别列表   | 获取所有产品类别                   |
+| /api/target-markets       | GET      | 无                                        | 目标市场列表   | 获取所有目标市场                   |
+
+## 5. 项目结构
+
+```
+[项目名称]/
+├── maternal_agent.py      # 核心母婴选品Agent实现
+├── web_agent.py           # Flask Web应用实现
+├── requirements.txt        # 项目依赖包
+├── README.md               # 项目说明文档
+└── 技术文档.md             # 技术文档
+```
+
+## 6. 核心功能
+
+### 6.1 选品分析功能
+
+- **产品类别分析**: 支持喂养用品、护理用品、服装服饰、安全座椅、玩具教具、出行用品、寝具用品等多个类别的产品分析
+- **目标市场分析**: 支持北美、欧洲、东南亚、中东等多个目标市场的分析
+- **竞品分析**: 提供竞品对比和分析功能
+- **趋势分析**: 分析市场趋势和消费者偏好
+- **利润率计算**: 提供产品利润率计算功能
+
+### 6.2 对话交互功能
+
+- **智能问答**: 提供关于跨境母婴选品的智能问答服务
+- **个性化推荐**: 根据用户需求提供个性化的产品推荐
+- **实时交互**: 支持与用户的实时对话交互
+
+### 6.3 Web界面功能
+
+- **可视化选品**: 提供直观的选品界面
+- **数据分析**: 展示选品分析结果和数据
+- **用户友好**: 响应式设计，支持多种设备访问
+
+## 7. 部署说明
+
+### 7.1 环境要求
+
+- Python 3.8+
+- pip 20.0+
+
+### 7.2 安装步骤
+
+1. 克隆项目代码到本地
+2. 安装依赖包：`pip install -r requirements.txt`
+3. 设置API密钥（可选）：`export DOUBAO_API_KEY=your_key` 或 `export OPENAI_API_KEY=your_key`
+4. 运行应用：`python web_agent.py`
+
+## 8. 使用说明
+
+### 8.1 Web应用界面
+
+1. 运行应用后，访问`http://localhost:5000`
+2. 在Web界面上选择产品类别和目标市场
+3. 点击"获取选品建议"按钮
+4. 查看系统返回的选品建议和市场分析报告
+5. 使用聊天功能与AI助手进行交互，获取更多选品相关信息
+
+## 9. 技术亮点
+
+1. **多模型支持**：自动检测并支持本地模型、豆包模型、OpenAI模型等多种AI模型
+2. **智能选品流程**：基于LazyLLM框架构建的选品流程，能够根据产品类别和目标市场提供精准的选品建议
+3. **多市场覆盖**：支持北美、欧洲、东南亚、中东等多个海外市场
+4. **完整的数据分析**：提供市场分析、竞争分析、利润率计算等完整的数据分析功能
+5. **灵活的部署方式**：基于Flask框架的Web应用，支持灵活部署和扩展
+
+## 10. 未来规划
+
+1. **增加更多产品类别**：扩展到更多母婴产品类别，如孕妇用品、产后恢复用品等
+2. **增加更多目标市场**：扩展到更多海外市场，如南美、非洲等
+3. **优化选品算法**：基于更多的市场数据和用户反馈，优化选品算法，提高选品建议的精准度
+4. **增加用户管理功能**：增加用户注册、登录、个人中心等功能，实现个性化的选品建议
+5. **增加数据可视化功能**：增加更多的数据可视化图表，如市场趋势图、产品对比图等，帮助用户更直观地了解市场情况
+
+## 3. 项目结构
+
+```
+[项目名称]/
+├── maternal_agent.py      # 核心母婴选品Agent实现
+├── web_agent.py           # Flask Web应用实现
+├── requirements.txt        # 项目依赖包
+├── README.md               # 项目说明文档
+└── 技术文档.md             # 技术文档
+```
+
+## 4. 核心功能
+
+### 4.1 选品分析功能
+
+- **产品类别分析**: 支持喂养用品、护理用品、服装服饰、安全座椅、玩具教具、出行用品、寝具用品等多个类别的产品分析
+- **目标市场分析**: 支持北美、欧洲、东南亚、中东等多个目标市场的分析
+- **竞品分析**: 提供竞品对比和分析功能
+- **趋势分析**: 分析市场趋势和消费者偏好
+
+### 4.2 对话交互功能
+
+- **智能问答**: 提供关于跨境母婴选品的智能问答服务
+- **个性化推荐**: 根据用户需求提供个性化的产品推荐
+- **实时交互**: 支持与用户的实时对话交互
+
+### 4.3 Web界面功能
+
+- **可视化选品**: 提供直观的选品界面
+- **数据分析**: 展示选品分析结果和数据
+- **用户友好**: 响应式设计，支持多种设备访问
+
+## 5. 核心模块说明
+
+### 5.1 CrossBorderMaternalAgent类
+
+位于`maternal_agent.py`文件中，是核心的选品Agent实现。
+
+**主要方法**:
+
+- `__init__()`: 初始化Agent，加载模型和数据
+- `_init_local_model()`: 初始化本地模型
+- `_create_mock_chat_module()`: 创建模拟聊天模块
+- `_build_selection_pipeline()`: 构建选品流程
+- `_build_chat_pipeline()`: 构建对话流程
+- `analyze_product()`: 分析产品
+- `analyze_market()`: 分析市场
+- `analyze_competitors()`: 分析竞品
+- `get_recommendations()`: 获取产品推荐
+- `chat()`: 对话交互
+
+### 5.2 Flask Web应用
+
+位于`web_agent.py`文件中，是基于Flask框架的Web应用实现。
+
+**主要功能**:
+
+- 提供HTML界面，支持用户与Agent的交互
+- 处理用户请求，调用Agent的相应方法
+- 返回JSON格式的响应，更新Web界面
+
+## 6. 使用方法
+
+### 6.1 环境配置
+
+1. 安装Python 3.x
+2. 安装项目依赖包:
+   ```bash
+   pip install -r requirements.txt
+   ```
+3. 配置API密钥（可选）:
+   ```bash
+   export DOUBAO_API_KEY=your_doubao_api_key
+   export OPENAI_API_KEY=your_openai_api_key
+   ```
+
+### 6.2 运行项目
+
+1. 启动Web应用:
+   ```bash
+   python web_agent.py
+   ```
+2. 打开浏览器访问:`http://localhost:5000`
+
+### 6.3 交互使用
+
+- 在Web界面上进行选品分析
+- 通过对话界面与Agent进行交互
+- 获取产品推荐和分析结果
+
+## 7. 扩展开发
+
+### 7.1 添加新的产品类别
+
+在`maternal_agent.py`文件中，修改`self.product_categories`字典，添加新的产品类别和特征。
+
+### 7.2 添加新的目标市场
+
+在`maternal_agent.py`文件中，修改`self.target_markets`字典，添加新的目标市场和偏好信息。
+
+### 7.3 扩展Web界面功能
+
+在`web_agent.py`文件中，修改HTML模板和Flask路由，添加新的Web界面功能。
+
+## 8. 故障排除
+
+### 8.1 模型加载失败
+
+- 检查API密钥是否正确配置
+- 检查网络连接是否正常
+- 尝试使用模拟聊天模块作为后备
+
+### 8.2 Web应用无法启动
+
+- 检查Python和Flask是否正确安装
+- 检查端口是否被占用
+- 查看错误日志，定位问题所在
+
+### 8.3 交互功能异常
+
+- 检查浏览器控制台是否有错误信息
+- 检查网络连接是否正常
+- 查看服务器日志，定位问题所在
+
+## 9. 版本历史
+
+- **v1.0**: 初始版本，包含基本的选品分析和对话交互功能
+
+## 10. 贡献指南
+
+- 提交代码前请进行充分测试
+- 遵循Python编码规范
+- 提交时请填写详细的变更说明
+
+## 11. 许可证
+
+本项目采用MIT许可证，详细信息请参考LICENSE文件。