# 使用Ollama本地部署Nemotron 3.5 Lightning
# 第一步：拉取模型
# 命令行执行: ollama pull nemotron-3.5-lightning

# 第二步：Python调用
import requests
import json

class NemotronLocalClient:
    """Nemotron 3.5 Lightning本地推理客户端"""

    def __init__(self, host="localhost", port=11434):
        self.base_url = f"http://{host}:{port}"
        self.model = "nemotron-3.5-lightning"

    def chat(self, messages, temperature=0.7, stream=False):
        """对话接口"""
        payload = {
            "model": self.model,
            "messages": messages,
            "stream": stream,
            "options": {
                "temperature": temperature,
                "num_ctx": 32768,  # 上下文窗口
                "num_gpu": 1,      # GPU层数
            }
        }

        response = requests.post(
            f"{self.base_url}/api/chat",
            json=payload
        )

        if stream:
            return self._parse_stream(response)
        else:
            result = response.json()
            return {
                "content": result["message"]["content"],
                "model": result["model"],
                "eval_count": result.get("eval_count", 0),
                "eval_duration": result.get("eval_duration", 0),
                "tokens_per_second": self._calc_tps(result)
            }

    def _calc_tps(self, result):
        """计算每秒token数"""
        eval_count = result.get("eval_count", 0)
        eval_duration_ns = result.get("eval_duration", 0)
        if eval_duration_ns > 0:
            return round(eval_count / (eval_duration_ns / 1e9), 1)
        return 0

    def _parse_stream(self, response):
        """解析流式响应"""
        for line in response.iter_lines():
            if line:
                data = json.loads(line)
                if "message" in data:
                    yield data["message"]["content"]

# 使用示例
client = NemotronLocalClient()

# 构建Agent工作流
agent_prompt = [
    {
        "role": "system",
        "content": """你是一个任务执行Agent。请按以下流程工作：
1. 分析用户请求，拆解为子任务
2. 为每个子任务制定执行计划
3. 逐步执行并验证结果
4. 汇总最终答案"""
    },
    {
        "role": "user",
        "content": "帮我分析Python和Rust在Web后端开发中的优劣，给出技术选型建议。"
    }
]

result = client.chat(agent_prompt, temperature=0.3)
print(f"模型: {result['model']}")
print(f"速度: {result['tokens_per_second']} tokens/s")
print(f"内容:
{result['content']}")

# NeMo Switchyard 智能路由示例
class SmartModelRouter:
    """基于任务复杂度的智能模型路由"""

    def __init__(self):
        self.models = {
            "lightweight": {
                "name": "nemotron-3.5-lightning",
                "cost_score": 1,    # 成本评分（1-10）
                "quality_score": 7,  # 质量评分（1-10）
                "speed_score": 9,   # 速度评分（1-10）
            },
            "frontier": {
                "name": "nemotron-4-frontier",
                "cost_score": 8,
                "quality_score": 10,
                "speed_score": 4,
            }
        }

        # 路由规则
        self.routing_rules = {
            "simple_qa": "lightweight",
            "code_generation": "lightweight",
            "tool_calling": "lightweight",
            "complex_reasoning": "frontier",
            "long_context_analysis": "frontier",
            "creative_writing": "frontier",
        }

    def classify_task(self, prompt):
        """简单的任务分类器"""
        prompt_lower = prompt.lower()

        if any(kw in prompt_lower for kw in ["分析", "推理", "论证", "对比分析"]):
            return "complex_reasoning"
        elif any(kw in prompt_lower for kw in ["写代码", "生成", "函数", "实现"]):
            return "code_generation"
        elif any(kw in prompt_lower for kw in ["调用", "执行", "查询"]):
            return "tool_calling"
        elif any(kw in prompt_lower for kw in ["什么是", "解释", "定义"]):
            return "simple_qa"
        elif any(kw in prompt_lower for kw in ["创意", "故事", "诗歌"]):
            return "creative_writing"
        else:
            return "complex_reasoning"  # 默认走复杂路径

    def route(self, prompt):
        """路由到最优模型"""
        task_type = self.classify_task(prompt)
        model_key = self.routing_rules[task_type]
        model_info = self.models[model_key]

        return {
            "task_type": task_type,
            "recommended_model": model_info["name"],
            "expected_cost": model_info["cost_score"],
            "expected_quality": model_info["quality_score"],
            "expected_speed": model_info["speed_score"]
        }

router = SmartModelRouter()

# 测试路由决策
test_prompts = [
    "什么是MoE架构？",
    "用Python实现一个红黑树",
    "分析量子计算对密码学的长期影响",
    "调用天气API获取北京今日天气"
]

for prompt in test_prompts:
    result = router.route(prompt)
    print(f"任务: {prompt[:30]}...")
    print(f"  → 类型: {result['task_type']}")
    print(f"  → 模型: {result['recommended_model']}")
    print(f"  → 成本/质量/速度: {result['expected_cost']}/{result['expected_quality']}/{result['expected_speed']}")
    print()

# 使用llama.cpp本地运行Muse Glimmer
# 命令行启动:
# ./main -m muse-glimmer-q4.gguf -c 131072 --n-gpu-layers 35

# Python调用（通过llama-cpp-python）
from llama_cpp import Llama

# 加载量化后的Glimmer模型
llm = Llama(
    model_path="./models/muse-glimmer-q4.gguf",
    n_ctx=131072,          # 128K上下文窗口
    n_gpu_layers=35,       # GPU加速层数
    n_threads=8,           # CPU线程数
    verbose=False
)

# 多模态推理（文本部分）
response = llm(
    "请解释Transformer架构中多头注意力机制的工作原理，并给出一个简化的PyTorch实现。",
    max_tokens=2048,
    temperature=0.7,
    top_p=0.9,
    stop=["

### Glimmer vs 竞品对比

| 维度 | Muse Glimmer | Llama 3.1 70B | Qwen3.8-Max | Nemotron 3.5 |
|------|-------------|---------------|-------------|--------------|
| 参数量 | ~30B | 70B | 2.4T | 30B |
| 许可证 | Apache 2.0 | Llama License | 开源 | OpenMDW-1.1 |
| 多模态 | 是（文本+图像） | 否 | 否 | 否 |
| 消费级GPU | 支持 | 需量化 | 不支持 | 支持 |
| 上下文 | 128K | 128K | 1M | 32K |
| 语言 | 100+ | ~30 | 100+ | ~30 |

## 阿里云Apache Fluss：实时AI数据基础设施

### 项目背景

在模型发布的同时，数据基础设施层面也有重要进展。阿里云开源的流式存储项目Apache Fluss正式从Apache软件基金会孵化器毕业，成为全球顶级开源项目，相关提案获委员会全票通过。

Fluss由阿里云Flink团队开发，定位为湖仓原生实时流存储层。其核心价值在于：在数据湖之上增加实时数据能力，为AI Agent提供秒级更新的上下文支撑。

### 技术架构

### 生产环境应用

目前Apache Fluss已在阿里、小红书、京东、蚂蚁、爱奇艺等企业生产环境落地，应用场景包括：

- 实时数仓：支持亚秒级数据更新，替代传统T+1批处理
- AI搜索推荐：为推荐系统提供实时用户行为数据流
- 索引链路：实时构建和更新搜索索引
- AI Agent上下文：为长时间运行的Agent提供实时环境数据

## 开源AI生态的2026年趋势

### 从追赶者到标准制定者

2026年8月的这波开源发布，标志着开源AI生态正在经历质的飞跃。过去开源模型总是在追赶闭源模型的能力上限，现在开源模型开始在特定领域（如Agent推理、多模态、消费级部署）定义新的性能标准。

### 开源vs闭源的路线之争

## 开发者实践建议

### 选择开源模型的决策框架

1. **明确使用场景**：Agent推理优先Nemotron 3.5，多模态优先Glimmer，通用对话两者皆可
2. **评估硬件条件**：消费级GPU选Glimmer或量化后的Nemotron，专业级GPU可运行完整精度模型
3. **考虑许可证**：Apache 2.0最宽松，OpenMDW-1.1支持商业使用但有额外条款
4. **测试工具链兼容性**：确认模型与你的推理框架（Ollama/vLLM/llama.cpp）兼容

### 混合部署策略