一起学大模型 - 动手写一写langchain调用本地大模型（1）

最新推荐文章于 2026-03-25 19:18:32 发布
原创 最新推荐文章于 2026-03-25 19:18:32 发布 · 1w 阅读 · 79 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#langchain #python

文章目录

前言

langchain的手册里只有使用在线openai接口这一个例子，实际运用中我们大部分还是要用本地的大模型的。所以我们一起尝试写一写，练一练

一、如何替代掉openai呢

替掉openai的关键是根据我们所使用的模型的具体调用方式来实现 generate 方法。LangChain 框架为我们提供了一个通用接口，我们需要根据不同模型的特点和 API 来重写这个接口中的方法，以便能够正确调用本地模型并生成所需的输出。

先看具体步骤

  1. 定义模型类：创建一个继承自 LangChain 的 BaseLLM 类，并根据所使用的本地模型重写 generate 方法。
  2. 加载模型和分词器：在模型类的初始化方法中加载你想要使用的本地模型和分词器。
  3. 实现生成方法：在 generate 方法中，处理输入文本并调用模型的生成函数，返回生成的文本。
  4. 构建管道：使用定义好的模型类和生成方法，构建从用户输入到输出的处理管道。

1. 定义模型类

我们以 GPT-2 为例，定义一个调用本地 GPT-2 模型的 LocalGPT2LLM 类：

import torch
from transformers import GPT2LMHeadModel, GPT2Tokenizer
from langchain.llms import BaseLLM

class LocalGPT2LLM(BaseLLM):
    def __init__(self, model_name='gpt2', device='cpu'):
        self.tokenizer = GPT2Tokenizer.from_pretrained(model_name)
        self.model = GPT2LMHeadModel.from_pretrained(model_name).to(device)
        self.device = device

    def generate(self, prompt, max_length=50, temperature=0.7):
        inputs = self.tokenizer(prompt, return_tensors='pt').to(self.device)
        with torch.no_grad():
            outputs = self.model.generate(
                inputs.input_ids,
                max_length=max_length,
                temperature=temperature,
                pad_token_id=self.tokenizer.eos_token_id
            )
        return self.tokenizer.decode(outputs[0], skip_special_tokens=True)

2. 构建处理管道

创建一个简单的管道类，整合模型的调用过程：

class NLPipeline:
    def __init__(self, llm):
        self.llm = llm

    def process(self, user_input):
        response = self.llm.generate(user_input)
        return response

3. 测试与应用

初始化模型和管道，并进行测试：

# 初始化本地模型
local_gpt2_llm = LocalGPT2LLM(device='cuda' if torch.cuda.is_available() else 'cpu')

# 创建 NLP 管道
pipeline = NLPipeline(local_gpt2_llm)

# 用户输入
user_input = "The quick brown fox jumps over the lazy dog."

# 处理用户输入并生成输出
output = pipeline.process(user_input)
print(f"Output: {output}")

4. 扩展支持其他模型

为了支持其他模型（例如 BERT 进行嵌入和 GPT-3 进行生成），可以类似地定义模型类并重写 generate 方法。这里我们以 BERT 嵌入和 GPT-3 生成的组合为例：

from transformers import BertModel, BertTokenizer
import openai

class BERTEmbedder:
    def __init__(self, model_name='bert-base-uncased'):
        self.tokenizer = BertTokenizer.from_pretrained(model_name)
        self.model = BertModel.from_pretrained(model_name)

    def embed(self, text):
        inputs = self.tokenizer(text, return_tensors='pt')
        with torch.no_grad():
            outputs = self.model(**inputs)
        return outputs.last_hidden_state.mean(dim=1).squeeze().numpy()

class GPT3LLM(BaseLLM):
    def __init__(self, temperature=0.7, max_tokens=150):
        self.temperature = temperature
        self.max_tokens = max_tokens

    def generate(self, prompt):
        response = openai.Completion.create(
            engine="text-davinci-003",
            prompt=prompt,
            temperature=self.temperature,
            max_tokens=self.max_tokens
        )
        return response.choices[0].text.strip()

# 创建和组合模型
bert_embedder = BERTEmbedder()
gpt3_llm = GPT3LLM()

# 定义组合的管道
class CombinedNLPipeline:
    def __init__(self, embedder, llm):
        self.embedder = embedder
        self.llm = llm

    def process(self, user_input):
        # 生成嵌入向量
        embedding = self.embedder.embed(user_input)
        prompt = f"User input embedding: {embedding}\nGenerate response:"
        # 使用 GPT-3 生成输出
        response = self.llm.generate(prompt)
        return response

# 创建组合管道
combined_pipeline = CombinedNLPipeline(bert_embedder, gpt3_llm)

# 测试输入
user_input = "The quick brown fox jumps over the lazy dog."
output = combined_pipeline.process(user_input)
print(f"Output: {output}")

5. 小结

通过这种方法，可以灵活地集成各种本地模型，并将其与 LangChain 框架结合，构建复杂的自然语言处理管道。根据不同的模型和需求，重写 generate 方法，实现多样化的处理和生成任务。

二、怎么用langchain自带的管道符

LangChain 提供了 LLMChain 类，可以更方便地将不同的模型和步骤组合在一起。下面是如何使用 LLMChain 来替代 CombinedNLPipeline，将 BERT 用于嵌入，GPT-3 用于生成的示例。

1. 安装必要的库

确保你已经安装了所需的库：

pip install transformers openai langchain

2. 定义 BERT 嵌入和 GPT-3 生成模型类

首先，定义用于生成嵌入的 BERT 模型类和用于生成文本的 GPT-3 模型类：

from transformers import BertModel, BertTokenizer
import openai
import torch
from langchain.llms import BaseLLM

# 定义 BERT 嵌入模型类
class BERTEmbedder:
    def __init__(self, model_name='bert-base-uncased'):
        self.tokenizer = BertTokenizer.from_pretrained(model_name)
        self.model = BertModel.from_pretrained(model_name)

    def embed(self, text):
        inputs = self.tokenizer(text, return_tensors='pt')
        with torch.no_grad():
            outputs = self.model(**inputs)
        return outputs.last_hidden_state.mean(dim=1).squeeze().numpy()

# 定义 GPT-3 生成模型类
class GPT3LLM(BaseLLM):
    def __init__(self, temperature=0.7, max_tokens=150):
        self.temperature = temperature
        self.max_tokens = max_tokens

    def generate(self, prompt):
        response = openai.Completion.create(
            engine="text-davinci-003",
            prompt=prompt,
            temperature=self.temperature,
            max_tokens=self.max_tokens
        )
        return response.choices[0].text.strip()

3. 使用 LangChain 的 LLMChain

接下来，使用 LangChain 的 LLMChain 类来替代手动定义的管道类。

from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
from langchain.embeddings import Embeddings

# 定义一个模板，将 BERT 的嵌入作为 GPT-3 的输入
prompt_template = PromptTemplate(
    template="User input embedding: {embedding}\nGenerate response:",
    input_variables=["embedding"]
)

# 实现一个嵌入模型类，用于在 LLMChain 中使用
class EmbeddingsWrapper(Embeddings):
    def __init__(self, embedder):
        self.embedder = embedder

    def embed(self, text):
        return self.embedder.embed(text)

# 初始化 BERT 嵌入模型和 GPT-3 生成模型
bert_embedder = BERTEmbedder()
gpt3_llm = GPT3LLM()

# 包装 BERT 嵌入模型
embedding_wrapper = EmbeddingsWrapper(bert_embedder)

# 创建 LLMChain
llm_chain = LLMChain(
    prompt_template=prompt_template,
    llm=gpt3_llm,
    embeddings=embedding_wrapper
)

# 用户输入
user_input = "The quick brown fox jumps over the lazy dog."

# 处理用户输入并生成输出
embedding = bert_embedder.embed(user_input)
output = llm_chain.run({"embedding": embedding})
print(f"Output: {output}")

4. 解释

  • BERTEmbedder 类：用于生成 BERT 嵌入。
  • GPT3LLM 类：用于调用 GPT-3 生成文本。
  • PromptTemplate：定义了 GPT-3 的提示模板，包含 BERT 生成的嵌入。
  • EmbeddingsWrapper 类：用于将 BERT 嵌入模型包装为 LangChain 的嵌入接口。
  • LLMChain：将 BERT 嵌入模型和 GPT-3 生成模型组合在一起，形成一个完整的处理管道。

5. 使用注意事项

  • 输入变量：确保 PromptTemplate 中的 input_variables 与实际输入变量匹配。
  • 模型配置：根据需要调整 GPT-3 和 BERT 模型的配置，如 temperature 和 max_tokens。

通过这种方式，使用 LangChain 的 LLMChain 类，可以更简洁地实现复杂的模型组合，简化代码结构，并提高可读性和维护性。

三、怎么才能用绝对地址引入本地模型呢

transformers 库支持从本地路径加载模型和分词器。只需要将 model_name 替换为模型和分词器所在的本地目录的绝对路径即可。

1. 使用本地模型路径的示例

假设你已经将 BERT 模型和分词器下载到本地目录 /path/to/local/bert-model，你可以这样进行修改：

from transformers import BertModel, BertTokenizer
import openai
import torch
from langchain.llms import BaseLLM

# 定义 BERT 嵌入模型类
class BERTEmbedder:
    def __init__(self, model_path='/path/to/local/bert-model'):
        self.tokenizer = BertTokenizer.from_pretrained(model_path)
        self.model = BertModel.from_pretrained(model_path)

    def embed(self, text):
        inputs = self.tokenizer(text, return_tensors='pt')
        with torch.no_grad():
            outputs = self.model(**inputs)
        return outputs.last_hidden_state.mean(dim=1).squeeze().numpy()

# 定义 GPT-3 生成模型类
class GPT3LLM(BaseLLM):
    def __init__(self, temperature=0.7, max_tokens=150):
        self.temperature = temperature
        self.max_tokens = max_tokens

    def generate(self, prompt):
        response = openai.Completion.create(
            engine="text-davinci-003",
            prompt=prompt,
            temperature=self.temperature,
            max_tokens=self.max_tokens
        )
        return response.choices[0].text.strip()

2. 组合使用 LangChain 的 LLMChain

下面是如何使用 LangChain 的 LLMChain 类，结合本地的 BERT 模型和 GPT-3：

from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
from langchain.embeddings import Embeddings

# 定义一个模板，将 BERT 的嵌入作为 GPT-3 的输入
prompt_template = PromptTemplate(
    template="User input embedding: {embedding}\nGenerate response:",
    input_variables=["embedding"]
)

# 实现一个嵌入模型类，用于在 LLMChain 中使用
class EmbeddingsWrapper(Embeddings):
    def __init__(self, embedder):
        self.embedder = embedder

    def embed(self, text):
        return self.embedder.embed(text)

# 初始化本地 BERT 嵌入模型和 GPT-3 生成模型
bert_embedder = BERTEmbedder(model_path='/path/to/local/bert-model')
gpt3_llm = GPT3LLM()

# 包装 BERT 嵌入模型
embedding_wrapper = EmbeddingsWrapper(bert_embedder)

# 创建 LLMChain
llm_chain = LLMChain(
    prompt_template=prompt_template,
    llm=gpt3_llm,
    embeddings=embedding_wrapper
)

# 用户输入
user_input = "The quick brown fox jumps over the lazy dog."

# 处理用户输入并生成输出
embedding = bert_embedder.embed(user_input)
output = llm_chain.run({"embedding": embedding})
print(f"Output: {output}")

3. 解释

  • model_path：将模型路径从预训练模型名称替换为本地目录的绝对路径。
  • BERTEmbedder 类：加载本地路径中的 BERT 模型和分词器。
  • LLMChain：与之前相同，定义一个 LangChain 的 LLMChain，用于将 BERT 嵌入和 GPT-3 生成结合起来。

通过这种方式，你可以方便地使用本地存储的模型文件，避免了每次使用时都需要从互联网下载模型文件。这样不仅可以节省时间，还可以在没有互联网连接的环境中使用模型。

总结

以上我们用三个章节介绍了如何调用本地模型，如何使用langchain自带的管道方法，以及如何从绝对地址来调用模型。 大家可以清晰的在各段代码里看到改变，可以尝试自己使用自己的方法。

Langchain+本地大语言模型进行数据库操作的实战代码
herosunly的博客
06-23 8万+
本文讲解了Langchain+本地大语言模型进行数据库操作的实战代码，希望能对尝试使用开源大语言模型进行SQL操作的同学们有所帮助。 文章目录 1. 前言 2. 代码思路剖析 3. 实战代码
如何使用Jupyter在LangChain环境下调用本地开源大模型进行问答
一个爱折腾技术的普通人，分享踩过的坑、学到的干货。
09-23 1077
本文介绍了在Anaconda环境下搭建LangChain框架并调用本地大模型的完整流程。首先配置LangChain环境并启动Jupyter Notebook，然后通过LMStudio下载并加载开源大模型（如Qwen3-0.6b）。重点演示了如何利用LangChain的Chain功能，将提示模板、模型调用和结果解析串联，实现营销文本生成。文章详细说明了输出解释器的作用，并对比了invoke批量获取和stream流式输出两种调用方式。最后展示了在Jupyter中成功调用本地模型进行问答和文本生成的效果，验证了该
langchain 如何使用本地大模型（LLM）
chwei20002005的博客
04-24 7691
langchain 如何使用本地的模型及常见的报错解决
LangChain调用大模型的两种方式
sinat_34898805的博客
01-09 1671
通过上述代码就将大模型下载到本机，这里下载的是Qwen2.5-1.5b模型，如果需要下载其他模型可以登录莫塔社区官网的大模型模块中自行选择，上面也有很详细的下载方法，此处不再赘述。此方式需要先到 https://ollama.com/ 下载Ollama并进行安装，安装成功后打开一个终端运行 ollama run qwen2.5:3b，意思是拉取并运行qwen2.5:3b。LangChain 社区包：pip install langchain-community。2、使用本机部署的大模型。
LangChain 如何调用 vLLM 本地部署的大模型
最新发布
二分掌柜的
03-25 694
flyfish
LangChain学习一：入门-本地化部署-接入大模型
huiguo_的博客
12-06 1万+
LangChain提供了一个标准的内存接口、一组内存实现及使用内存的链/代理示例。前提条件你是部署好了你的本地大模型，并且提供了API接口，如果你还不会搭建本地模型，你可以参考我的另一篇博客。如果你是在国外或者学会了科学上网，并且你在openai注册了key，你就可以使用opanai的模块进行调用。当然应为我们选择LangChain最为我们的中间件，我们也可以使用LangChain封装的模块使用。提供了一个标准的代理接口，一系列可供选择的代理，以及端到端代理的示例。在下载之前你需要安装环境。
langchain加载本地中文模型的4种方法
qq_29837229的博客
04-01 1万+
langchain如何加载本地中文模型
LangChain 安装与环境搭建，并调用OpenAI与Ollama本地大模型
博客虽小，世界尽在其中
03-31 2706
如果把大语言模型（LLM）比作一个强大的“智能大脑”，那么LangChain就像是它的“手和脚”——帮助这个大脑连接外部世界，完成更复杂的任务。🌟 LangChain 是什么？LangChain 是一个用于构建智能应用的框架，它让大语言模型（如 ChatGPT、Llama、Claude 等）能够更好地记忆、思考、规划，并与各种外部工具（数据库、API、搜索引擎等）进行交互。🚀 为什么要用 LangChain？单独使用 ChatGPT，你只能进行简单的对话；
【LLM】二、python调用本地的ollama部署的大模型
热门推荐
qq_55068938的博客
07-08 3万+
本地部署了大模型，下一步任务便是如何调用的问题，实际场景中个人感觉用http请求的方式较为合理，本篇文章也将通过http请求的方式来调用我们本地部署的大模型，正文开始。
【langchain/入门】使用langchain调用本地部署的大模型(以llama.cpp以及ollama为例)
o0o
03-11 2888
langchain入门教程第二篇，使用本地部署的大模型（包含ollama以及llama.cpp）
LangChain 本地化方案 - 使用 ChatYuan-large-v2 作为 LLM 大语言模型
小毕超博客
07-15 5067
ChatYuan-large-v2 是一个开源的支持中英双语的功能型对话语言大模型，与其他 LLM 不同的是模型十分轻量化，并且在轻量化的同时效果相对还不错，仅仅通过0.7B参数量就可以实现`10B`模型的基础效果，正是其如此的轻量级，使其可以在普通显卡、 CPU、甚至手机上进行推理，而且 INT4 量化后的最低只需 400M 。
LangChain之模型调用
积跬步，至千里。
04-22 2264
LangChain的模型是框架中的核心，基于语言模型构建，用于开发LangChain应用。通过API调用大模型来解决问题是LangChain应用开发的关键过程。
[langchain教程]langchain01——用langchain调用大模型
m0_69281817的博客
03-27 1584
LangChain 是一个开源框架，旨在简化基于大型语言模型（LLMs）的应用程序开发。通过模块化组件和链式结构将语言模型与外部数据源、工具和任务流程集成，构建复杂且功能强大的应用程序。
LangChain+本地大模型实现对话问答开发入门案例
月光冷锋的博客
02-18 1947
LangChain是一个AI应用快速开发的代码层面框架，类似我们用Jedis组件去访问Redis服务一样。大语言模型LLM就相当于这里的Redis服务一样，独立部署的第三方中间件。所以开发时需要先部署一个大语言模型，可以是直接使用第三方厂商已经部署好的使用API+秘钥方式访问。这里我们使用本地部署大模型方式进行模拟开发。同时在Python和java开发环境下进行验证示例。
[NLP] 使用Llama.cpp和LangChain在CPU上使用大模型-RAG
摩登都市天空---专栏
11-07 7089
下载llama-cpp, llama-cpp-pythonLangChain是一个提供了一组广泛的集成和数据连接器，允许我们链接和编排不同的模块。可以常见聊天机器人、数据分析和文档问答等应用。sentence-transformer提供了简单的方法来计算句子、文本和图像的嵌入。它能够计算100多种语言的嵌入。我们将在这个项目中使用开源的all-MiniLM-L6-v2模型。Facebook AI相似度搜索(FAISS)是一个为高效相似度搜索和密集向量聚类而设计的库。
最强开源大模型炸场！全网独一份AI大模型学习实践资源...（待会删）
Y525698136的博客
08-07 1590
最强开源大模型炸场！全网独一份AI大模型学习实践资源...（待会删）
基于LangChain-ChatGLM量化后的大模型本地部署
m0_67472400的博客
08-04 3514
基于开源LangChain-ChatGLM的ChatGLM-6B-INT4本地部署
LangChain+本地文本嵌入模型+本地向量库，实现文本相似性增强检索功能
月光冷锋的博客
02-19 1972
langChain是一个AI开发细节封装框架，可以让你非常方便的在Python和java环境下进行AI应用开发。传统的文本检索设计方案一般都是使用数据库进行模糊匹配或者使用更先进的ES等中间件进行更高效的文本模糊检索功能。这种检索方式还是依赖传统的用户输入文本，对其进行合理分词，然后再去系统中进行部分字词的模糊匹配目标文档。然而这种检索方式对文本相似性检索却无能为力，比如包含近义词或含义相似的文档就检索不到了。实际上用户可能非常需要将其一并查询出来工用户参考。
【LLM】Langchain使用[一]（模型、提示和解析器、存储）
发现问题，并解决问题，批判性思维
07-15 4081
为各种不同基础模型提供统一接口帮助管理提示的框架一套中心化接口，用于处理长期记忆（参见Memory）、外部数据（参见Indexes）、其他 LLM（参见Chains）以及 LLM 无法处理的任务的其他代理（例如，计算或搜索）。Models：从不同的 LLM 和嵌入模型中进行选择Prompts：管理 LLM 输入Chains：将 LLM 与其他组件相结合Indexes：访问外部数据Memory：记住以前的对话Agents：访问其他工具。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值