curl -fsSL https://ollama.com/install.sh | sh

brew install ollama

ollama --version
# 输出示例：ollama version 0.5.7

# 运行 7B 版本（推荐，约 4.7GB 磁盘空间）
ollama run deepseek-r1:7b

# 或运行 1.5B 版本（适合低配机器）
ollama run deepseek-r1:1.5b

# 或运行 8B Llama 蒸馏版
ollama run deepseek-r1:8b

>>> 用 Python 实现一个快速排序算法，并解释其时间复杂度

# Linux 系统：编辑 ollama 服务文件
sudo systemctl edit ollama.service

[Service]
Environment="OLLAMA_HOST=0.0.0.0"

sudo systemctl daemon-reload
sudo systemctl restart ollama

curl http://localhost:11434/api/chat -d '{
  "model": "deepseek-r1:7b",
  "messages": [{"role": "user", "content": "你好，请介绍一下你自己"}],
  "stream": false
}'

# 设置并发请求队列长度
export OLLAMA_NUM_PARALLEL=4
# 设置每个请求的最大 token 数
export OLLAMA_MAX_LOADED_MODELS=2

# 设置环境变量
export OLLAMA_MODELS=/path/to/new/models
# 移动已有模型
mv ~/.ollama/models/* $OLLAMA_MODELS/

git clone https://github.com/langgenius/dify.git
cd dify/docker

cp .env.example .env

# 密钥配置（必须修改！）
SECRET_KEY=$(openssl rand -base64 42)

# 数据库配置（生产环境建议使用外部数据库）
POSTGRES_USER=dify
POSTGRES_PASSWORD=dify123
POSTGRES_DB=dify

# Redis 配置
REDIS_PASSWORD=dify123

# 存储配置（生产环境建议使用 S3/MinIO）
STORAGE_TYPE=local
STORAGE_LOCAL_PATH=storage

docker compose up -d

extra_hosts:
  - "host.docker.internal:host-gateway"

你是一个专业的编程助手。对于每个问题，请先进行深度思考（用 思考 标签包裹推理过程），然后给出完整的答案。

你是 DeepSeek-R1 驱动的全能 AI 助手，拥有以下能力：

1. 深度推理：对于复杂问题，你会逐步分析，确保逻辑缜密
2. 工具调用：你可以使用提供的工具来获取信息、执行操作
3. 代码生成：你可以编写、调试和优化代码
4. 知识整合：你可以综合多个信息源给出答案

工作流程：
1. 当收到用户请求时，先理解问题本质
2. 如果需要外部信息，调用对应的工具
3. 综合推理结果和工具返回信息，给出最终答案
4. 如果是代码问题，提供可运行且经过优化的代码

注意事项：
- 始终使用中文回复
- 代码必须包含类型注解和文档字符串
- 对于不确定的信息，明确告知用户存在不确定性

用户输入
    ↓
[LLM 节点] DeepSeek-R1 推理分析
    ↓
[条件判断] 是否需要工具调用？
    ├── 是 → 调用对应工具 → 返回结果 → [LLM 节点] 综合分析 → 输出
    └── 否 → 直接输出答案
    ↓
[输出节点] 格式化最终回复

inputs:
  - name: query
    type: string
    required: true
  - name: context
    type: string
    required: false
    default: ""

system: >
  你是一个智能助手。请按以下步骤处理用户请求：
  1. 分析用户意图
  2. 如果需要工具，列出所需工具
  3. 逐步推理并给出答案

user: >
  {{#context#}}
  用户问题：{{#query#}}

  请开始你的推理过程。

def main(query: str, code: str) -> str:
    """
    在沙箱环境中执行用户请求的代码

    Args:
        query: 用户的原始请求
        code: LLM 生成的代码

    Returns:
        执行结果或错误信息
    """
    try:
        # 创建安全的执行环境
        local_vars = {}
        exec(code, {"__builtins__": __builtins__}, local_vars)
        return str(local_vars.get("result", "代码执行完成"))
    except Exception as e:
        return f"执行出错：{str(e)}"

knowledge_base: 企业技术文档库
retrieval_mode: hybrid  # 混合检索（关键词 + 向量）
top_k: 5
score_threshold: 0.7

output_template: >
  ## 回答

  {{#answer#}}

  ---
  *本文由 DeepSeek-R1 驱动生成*

# 步骤 1：代码审查 Agent 的工作流配置

# 在 Dify 工作流编辑器中配置如下节点链：
# Start → Code Analysis → LLM Review → Fix Generation → End

# 步骤 2：代码分析节点（Python 代码执行）
def analyze_code(code: str) -> dict:
    """静态代码分析"""
    import ast
    import pylint  # 如果安装了 pylint

    results = {
        "ast_errors": [],
        "complexity": 0,
        "functions": [],
        "classes": [],
        "issues": []
    }

    try:
        tree = ast.parse(code)

        for node in ast.walk(tree):
            # 检测函数复杂度
            if isinstance(node, ast.FunctionDef):
                func_info = {
                    "name": node.name,
                    "lineno": node.lineno,
                    "args_count": len(node.args.args)
                }
                results["functions"].append(func_info)

                # 统计 if/for/while 数量
                complexity = sum(1 for child in ast.walk(node) 
                                if isinstance(child, (ast.If, ast.For, ast.While)))
                results["complexity"] = max(results["complexity"], complexity)

            # 检测潜在安全问题
            if isinstance(node, ast.Call):
                if isinstance(node.func, ast.Attribute):
                    if node.func.attr in ("eval", "exec", "__import__"):
                        results["issues"].append({
                            "type": "security",
                            "message": f"发现危险函数调用: {node.func.attr}",
                            "line": node.lineno
                        })

    except SyntaxError as e:
        results["ast_errors"].append({
            "type": "syntax",
            "message": str(e)
        })

    return results

文档上传 → 文档解析 → 文本分块 → 向量化 → 向量存储
                                                  ↓
用户提问 → 问题向量化 → 向量检索 → 上下文组装 → LLM 推理 → 答案

chunk_strategy:
  mode: paragraph  # 按段落分段
  max_tokens: 512  # 每段最大 token 数
  overlap: 50      # 段落重叠 token 数
  separator: "\n\n" # 段落分隔符

# 部署 BGE 嵌入模型
ollama pull bge-m3

# 或使用更轻量的版本
ollama pull bge-small

node_type: knowledge_retrieval
config:
  knowledge_base: 企业技术文档库
  retrieval_mode: multi_way  # 多路召回

  # 多路召回策略
  strategies:
    - type: vector  # 向量检索
      weight: 0.6
      top_k: 5

    - type: keyword  # 关键词检索（BM25）
      weight: 0.3
      top_k: 3

    - type: hybrid  # 混合检索
      weight: 0.1
      top_k: 2

  # 重排序
  rerank:
    enabled: true
    model: bge-reranker-v2-m3
    top_k: 5

  # 上下文组装
  context_template: |
    以下是与用户问题相关的内容：

    {% for doc in documents %}
    [来源 {{ loop.index }}]: {{ doc.content }}
    ---
    {% endfor %}

    请基于以上内容回答用户的问题。如果内容不足以回答问题，请说明。

# 完整的 Dify 工作流 YAML 配置
app:
  name: API 文档助手
  description: 基于 DeepSeek-R1 的 API 文档智能问答系统

workflow:
  nodes:
    - id: start
      type: start
      config:
        inputs:
          - name: question
            type: string
            required: true

    - id: query_rewrite
      type: llm
      model: deepseek-r1:7b
      config:
        temperature: 0.3
        prompt: |
          你是一个查询重写助手。将用户的自然语言问题改写为更适合搜索的查询语句。
          用户问题：{{ question }}

          改写后的查询（只输出改写结果，不要任何解释）：

    - id: knowledge_search
      type: knowledge_retrieval
      config:
        knowledge_base: API 文档库
        query: "{{ query_rewrite.output }}"
        top_k: 5

    - id: answer_generation
      type: llm
      model: deepseek-r1:7b
      config:
        temperature: 0.5
        prompt: |
          你是一个 API 文档专家。请根据以下参考内容回答用户问题。

          ## 参考内容
          {{ knowledge_search.output }}

          ## 用户问题
          {{ question }}

          请按以下格式回答：
          1. 直接答案
          2. 代码示例（如有）
          3. 注意事项
          4. 相关链接

    - id: end
      type: end
      config:
        output: "{{ answer_generation.output }}"

# 使用 Ollama 支持的量化版本
ollama pull deepseek-r1:7b-q4_K_M  # 4-bit 量化，约 4GB 显存
ollama pull deepseek-r1:7b-q8_0    # 8-bit 量化，约 6GB 显存

# Ollama 运行时参数
OLLAMA_KV_CACHE_TYPE: "q8_0"    # KV Cache 量化
OLLAMA_GPU_OVERHEAD: 0.2         # GPU 预留空间比例
OLLAMA_NUM_GPU: 1                # 使用的 GPU 数量

import requests
import json
from concurrent.futures import ThreadPoolExecutor

def batch_infer(prompts: list[str], model: str = "deepseek-r1:7b"):
    """批量推理"""
    results = []

    def single_infer(prompt):
        response = requests.post(
            "http://localhost:11434/api/generate",
            json={
                "model": model,
                "prompt": prompt,
                "stream": False,
                "options": {
                    "num_predict": 512,
                    "temperature": 0.7
                }
            }
        )
        return response.json()["response"]

    with ThreadPoolExecutor(max_workers=4) as executor:
        results = list(executor.map(single_infer, prompts))

    return results

# docker-compose.yml
services:
  dify-api:
    environment:
      DB_POOL_SIZE: 20
      DB_MAX_OVERFLOW: 40
      DB_POOL_PRE_PING: true

  dify-db:
    image: postgres:15-alpine
    environment:
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    volumes:
      - ./data/postgres:/var/lib/postgresql/data
    deploy:
      resources:
        limits:
          memory: 2G

services:
  dify-redis:
    image: redis:7-alpine
    command: redis-server --requirepass ${REDIS_PASSWORD} --maxmemory 1gb --maxmemory-policy allkeys-lru
    volumes:
      - ./data/redis:/data

services:
  dify-weaviate:
    image: semitechnologies/weaviate:latest
    environment:
      QUERY_DEFAULTS_LIMIT: 25
      AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED: false
      PERSISTENCE_DATA_PATH: /var/lib/weaviate
      DEFAULT_VECTORIZER_MODULE: text2vec-transformers
      TRANSFORMERS_INFERENCE_API: http://t2v-transformers:8080
    volumes:
      - ./data/weaviate:/var/lib/weaviate

# k8s-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: dify-api
spec:
  replicas: 3
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 1
  template:
    spec:
      containers:
      - name: dify-api
        image: langgenius/dify-api:latest
        resources:
          requests:
            cpu: 500m
            memory: 512Mi
          limits:
            cpu: 2
            memory: 2Gi
        env:
        - name: DB_HOST
          valueFrom:
            configMapKeyRef:
              name: dify-config
              key: db_host
        - name: REDIS_HOST
          valueFrom:
            configMapKeyRef:
              name: dify-config
              key: redis_host
        livenessProbe:
          httpGet:
            path: /health
            port: 5001
          initialDelaySeconds: 30
          periodSeconds: 10

架构设计:
  数据层:
    - 用户历史对话（PostgreSQL）
    - 产品知识库（Weaviate）
    - FAQ 数据库（Redis）

  推理层:
    - DeepSeek-R1 7B（核心推理）
    - BGE Embedding（文本向量化）

  应用层:
    - Dify Agent（对话管理）
    - Webhook（工单系统对接）
    - Email/SMS（升级到人工）

# GitHub Actions 集成示例
# .github/workflows/code-review.yml
name: AI Code Review
on: [pull_request]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Get diff
        id: diff
        run: |
          git diff origin/main > /tmp/diff.txt
          echo "diff<<EOF" >> $GITHUB_OUTPUT
          cat /tmp/diff.txt >> $GITHUB_OUTPUT
          echo "EOF" >> $GITHUB_OUTPUT

      - name: AI Review
        run: |
          curl -X POST http://dify-server/api/workflows/run \
            -H "Authorization: Bearer ${{ secrets.DIFY_API_KEY }}" \
            -H "Content-Type: application/json" \
            -d '{
              "inputs": {
                "diff": "'"${{ steps.diff.outputs.diff }}"'",
                "repo": "${{ github.repository }}",
                "branch": "${{ github.head_ref }}"
              },
              "response_mode": "blocking"
            }'

工作流设计:
  - 用户输入: "上个月销售额排名前10的产品是哪些？"
  - LLM 推理: 
    → 理解意图 → 识别表结构 → 生成 SQL
  - 代码执行:
    → 执行 SQL 查询 → 返回结果
  - LLM 总结:
    → 格式化结果 → 生成可视化建议

# 1. 检查 Ollama 是否运行
systemctl status ollama

# 2. 检查监听地址
ss -tlnp | grep 11434

# 3. 从 Docker 容器内测试
docker exec dify-api curl http://host.docker.internal:11434

# 4. 检查防火墙
sudo ufw status

# 1. 使用更小的量化版本
ollama pull deepseek-r1:7b-q4_K_M

# 2. 限制 GPU 使用
export CUDA_VISIBLE_DEVICES=0
ollama run deepseek-r1:7b

# 3. 启用 CPU offloading
ollama run deepseek-r1:7b --num-gpu 0  # 纯 CPU 运行

1. 硬件层面：
   - 升级 GPU（推荐 RTX 4090 或 A100）
   - 确保 PCIe 带宽足够（至少 PCIe 4.0 x16）

2. 软件层面：
   - 使用 Flash Attention 加速
   - 开启 CUDA Graph
   - 使用 vLLM 替代 Ollama（高并发场景）

3. 架构层面：
   - 引入缓存层（Redis）
   - 使用异步处理
   - 负载均衡（多实例部署）