大模型选择与私有化部署#

1
所需显存(GB) ≈ 模型参数量(B) × 量化位数 / 8 + 2GB（overhead）

1
# pip install langchain langchain-ollama
2

3
from langchain_ollama import ChatOllama
4

5
# 创建模型实例，连接本地 Ollama 服务
6
llm = ChatOllama(
7
    model="qwen3:14b",
8
    base_url="http://localhost:11434",  # 默认值，可省略
9
    temperature=0.7,
10
    num_predict=1024,  # 最大输出 Token 数
11
)
12

13
# 简单调用
14
response = llm.invoke("用一句话解释什么是 LangChain")
15
print(response.content)

1
# pip install langchain langchain-ollama langchain-core
2

3
from langchain_ollama import ChatOllama
4
from langchain_core.prompts import ChatPromptTemplate
5
from langchain_core.output_parsers import StrOutputParser
6

7
# 构建模型
8
llm = ChatOllama(model="qwen3:14b", temperature=0.7)
9

10
# 构建 Prompt 模板
11
prompt = ChatPromptTemplate.from_messages([
12
    ("system", "你是一位资深的技术专家，善于用通俗易懂的语言解释复杂概念。"),
13
    ("human", "请解释以下概念：{concept}"),
14
])
15

16
# 构建 LCEL Chain（参考 [[01_LangChain概述与核心架构]]）
17
chain = prompt | llm | StrOutputParser()
18

19
# 调用 Chain
20
result = chain.invoke({"concept": "向量数据库在 RAG 中的作用"})
21
print(result)

1
# pip install langchain langchain-ollama langchain-core
2

3
from langchain_ollama import ChatOllama
4
from langchain_core.prompts import ChatPromptTemplate
5
from langchain_core.output_parsers import StrOutputParser
6

7
llm = ChatOllama(model="qwen3:14b", temperature=0.7)
8

9
prompt = ChatPromptTemplate.from_messages([
10
    ("human", "{question}"),
11
])
12

13
chain = prompt | llm | StrOutputParser()
14

15
# 流式输出
16
for chunk in chain.stream({"question": "Python 异步编程的核心概念有哪些？"}):
17
    print(chunk, end="", flush=True)

1
# pip install langchain langchain-ollama langchain-core
2

3
from langchain_ollama import ChatOllama
4
from langchain_core.messages import HumanMessage
5

6
# 启用深度思考模式（模型会先推理再回答）
7
llm = ChatOllama(model="qwen3:14b", temperature=0.7)
8

9
# 方法一：通过 Prompt 引导思考
10
response = llm.invoke("请一步一步思考：如果一个水池有两个进水管和一个出水管，"
11
                       "进水管每小时分别注入 3 吨和 5 吨水，出水管每小时排出 2 吨水，"
12
                       "水池容量为 48 吨，多久能装满？")
13
print(response.content)
14

15
# 方法二：通过 /no_think 关闭思考（快速回答模式）
16
response = llm.invoke("/no_think 今天星期几？")
17
print(response.content)

1
# pip install langchain langchain-ollama langchain-core
2

3
from langchain_ollama import ChatOllama
4
from langchain_core.prompts import ChatPromptTemplate
5
from langchain_core.output_parsers import StrOutputParser
6

7
# 创建 Deepseek-R1 模型实例
8
llm = ChatOllama(
9
    model="deepseek-r1:14b",
10
    temperature=0.6,  # 推理任务建议稍低温度
11
    num_predict=2048,  # 推理过程可能较长，需要更多输出空间
12
)
13

14
# 数学推理测试
15
prompt = ChatPromptTemplate.from_messages([
16
    ("human", "{question}"),
17
])
18

19
chain = prompt | llm | StrOutputParser()
20

21
result = chain.invoke({
22
    "question": "证明：对于任意正整数 n，n^3 - n 能被 6 整除。"
23
})
24
print(result)

1
# pip install langchain langchain-ollama langchain-core
2

3
import re
4
from langchain_ollama import ChatOllama
5
from langchain_core.output_parsers import StrOutputParser
6

7
llm = ChatOllama(model="deepseek-r1:14b", temperature=0.6)
8

9
response = llm.invoke("一个骰子掷两次，两次点数之和为 7 的概率是多少？")
10
content = response.content
11

12
# 分离思维链和最终答案
13
think_match = re.search(r"<think>(.*?)</think>", content, re.DOTALL)
14
if think_match:
15
    thinking = think_match.group(1).strip()
16
    answer = content[think_match.end():].strip()
17
    print("=== 推理过程 ===")
18
    print(thinking)
19
    print("\n=== 最终答案 ===")
20
    print(answer)
21
else:
22
    print(content)

1
# pip install langchain langchain-ollama langchain-core
2

3
from langchain_ollama import ChatOllama
4
from langchain_core.prompts import ChatPromptTemplate
5
from langchain_core.output_parsers import StrOutputParser
6
from langchain_core.runnables import RunnableBranch, RunnableLambda
7

8
# 初始化两个模型
9
qwen = ChatOllama(model="qwen3:14b", temperature=0.7)
10
deepseek = ChatOllama(model="deepseek-r1:14b", temperature=0.6)
11

12
prompt = ChatPromptTemplate.from_messages([("human", "{question}")])
13

14
# 简单分类函数：判断是否是推理密集型任务
15
def is_reasoning_task(input_dict: dict) -> bool:
16
    keywords = ["证明", "计算", "推导", "为什么", "分析原因", "数学", "概率"]
17
    return any(kw in input_dict["question"] for kw in keywords)
18

19
# 构建路由 Chain
20
chain = prompt | RunnableBranch(
21
    (RunnableLambda(is_reasoning_task), deepseek),
22
    qwen,  # 默认分支
23
) | StrOutputParser()
24

25
# 测试
26
print(chain.invoke({"question": "你好，介绍一下你自己"}))  # → Qwen3
27
print(chain.invoke({"question": "证明勾股定理"}))  # → Deepseek-R1

1
# pip install langchain langchain-openai
2

3
from langchain_openai import ChatOpenAI
4

5
# vLLM 提供 OpenAI 兼容接口，直接使用 ChatOpenAI 连接
6
llm = ChatOpenAI(
7
    base_url="http://localhost:8000/v1",
8
    api_key="not-needed",  # vLLM 本地部署无需 API Key
9
    model="Qwen/Qwen3-14B",
10
    temperature=0.7,
11
)
12

13
response = llm.invoke("用 Python 实现二分查找")
14
print(response.content)