LLM TREND

大模型技术趋势分享：LLM、RAG、Prompt、Agent、Fine-tuning等

LLM

使用 Django 和 LangChain 构建智能聊天应用：集成 GPT-4o-mini 模型

By llmtrend #大模型

在 2025 年，大模型技术日新月异，如何将这些先进的 AI 能力无缝集成到现有 Web 应用中成为了一个关键问题。本文将以Django框架为基础，结合LangChain强大的大模型编排能力，并利用 OpenAI 最新的 GPT-4o-mini 模型，一步步构建一个具有持久会话和智能回复的 AI 聊天应用。这套方案非常适合用于构建 SaaS 产品、客户支持系统或者教育工具。通过本文，你将了解如何在 Django 项目中有效利用大模型，提升用户体验和产品竞争力。

准备工作与环境配置

在开始之前，我们需要准备一些必要的环境和工具。首先，你需要安装 Python 3.10+ 和 Django 4.2+。此外，你还需要一个有效的 OpenAI API 密钥。这是连接 GPT-4o-mini 模型 的关键。

使用 pip 安装以下依赖包：

pip install langchain-openai langchain-core langchain python-dotenv django-widget-tweaks django-markdownify

这些依赖包分别用于：

  • langchain-openai 和 langchain-core: 连接和使用 OpenAI 的 大模型。
  • langchain: LangChain 框架的核心库，用于构建复杂的 AI 应用流程。
  • python-dotenv: 用于加载环境变量，保护 API 密钥。
  • django-widget-tweaks: 用于更方便地控制 Django 表单的渲染。
  • django-markdownify: 用于在模板中渲染 Markdown 格式的文本。

安装完成后，在 settings.py 文件中的 INSTALLED_APPS 中添加以下应用：

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'widget_tweaks',
    'markdownify',
    'chats', # 你自己的聊天应用
]

请确保 chats 是你创建的 Django 应用的名称。

数据模型设计：ChatSession 和 Message

为了实现持久会话和聊天历史记录，我们需要定义合适的数据模型。这里使用 Django 的 ORM 来创建两个模型：ChatSession 和 Message。

ChatSession 模型代表一个独立的聊天会话，使用 UUID 作为主键，并记录会话的创建时间。

from django.db import models
import uuid

class ChatSession(models.Model):
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    created = models.DateTimeField(auto_now_add=True)

    @property
    def messages(self):
        return self.messages.all()

    def __str__(self):
        return str(self.id)

Message 模型代表一条聊天消息，包含消息所属的会话、发送者（人或 AI）、消息内容和创建时间。通过 ForeignKey 将 Message 模型与 ChatSession 模型关联起来，并使用 related_name='messages' 允许我们方便地通过 session.messages 访问会话中的所有消息。

class Message(models.Model):
    session = models.ForeignKey(ChatSession, on_delete=models.CASCADE, related_name='messages')
    sender = models.CharField(max_length=10, choices=(('human', 'Human'), ('ai', 'AI')))
    text = models.TextField()
    created = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        preview = (self.text[:30] + '...') if len(self.text) > 30 else self.text
        return f"{self.sender.capitalize()} @ {self.created.strftime('%Y-%m-%d %H:%M:%S')}:{preview}"

这种模型设计使得我们可以方便地存储和检索聊天历史，为 大模型 提供上下文信息，从而提升回复的质量。

用户输入表单：ChatForm

ChatForm 是一个简单的 Django 表单，用于捕获用户的输入。它使用 CharField 和 Textarea widget，允许用户输入多行文本。通过设置 placeholder 和 rows 属性，可以改善用户体验。

from django import forms

class ChatForm(forms.Form):
    user_input = forms.CharField(
        label="Your Message",
        max_length=500,
        widget=forms.Textarea(attrs={
            "rows": 3,
            "placeholder": "Ask me anything...",
        })
    )

这个表单是用户与 大模型 交互的入口，简洁的设计有助于提高用户参与度。

AI 响应生成器：LangChain 与 GPT-4o-mini 模型

generate_response 函数是整个应用的核心，它负责接收用户输入和聊天历史，使用 LangChain 编排 GPT-4o-mini 模型，生成 AI 响应。

首先，加载环境变量，包括 OpenAI API 密钥。

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain.schema import StrOutputParser
from langchain_core.messages import SystemMessage, HumanMessage, AIMessage
import os
from dotenv import load_dotenv

load_dotenv()
OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')

然后，初始化 GPT-4o-mini 模型。

llm = ChatOpenAI(model='gpt-4o-mini', openai_api_key=OPENAI_API_KEY)
system_prompt = SystemMessage(content="You are a helpful assistant.")

SystemMessage 用于设定 大模型 的角色，例如“你是一个乐于助人的助手”。

generate_response 函数将聊天历史转换为 LangChain 可以理解的 HumanMessage 和 AIMessage 对象，并构建一个 prompt 链。

def generate_response(user_input, history):
    history_msgs = []
    for msg in history:
        if msg.sender == 'human':
            history_msgs.append(HumanMessage(content=msg.text))
        elif msg.sender == 'ai':
            history_msgs.append(AIMessage(content=msg.text))

    history_msgs.append(HumanMessage(content=user_input))

    prompt = ChatPromptTemplate.from_messages([system_prompt] + history_msgs)
    chain = prompt | llm | StrOutputParser()
    return chain.invoke({})

这个 prompt 链包括以下步骤：

  1. 使用 ChatPromptTemplate 将 SystemMessage 和聊天历史转换为一个完整的 prompt。
  2. 将 prompt 传递给 GPT-4o-mini 模型。
  3. 使用 StrOutputParser 将模型的输出转换为纯文本。

通过 LangChain 的灵活编排，我们可以轻松地将 大模型 集成到 Django 应用中，并充分利用其强大的生成能力。

视图函数：处理用户交互与会话管理

Django 视图函数负责处理用户请求，与数据模型交互，并调用 AI 响应生成器。

home 视图渲染首页，提供一个开始新会话的入口。

from django.shortcuts import render, redirect, get_object_or_404
from .forms import ChatForm
from .models import ChatSession, Message
from .utils import generate_response

def home(request):
    return render(request, 'chats/home.html')

new_chat 视图创建一个新的 ChatSession 对象，并重定向到该会话的聊天页面。

def new_chat(request):
    session = ChatSession.objects.create()
    return redirect('chats:chat', id=str(session.id))

chat_view 视图处理聊天页面的 GET 和 POST 请求。当收到 POST 请求时，它从表单中获取用户输入，从数据库中获取最近的聊天历史，调用 generate_response 函数生成 AI 响应，并将用户输入和 AI 响应保存到数据库中。然后，它重定向回同一个页面，以显示新的聊天消息。

def chat_view(request, id):
    session = get_object_or_404(ChatSession, id=id)

    if request.method == 'POST':
        form = ChatForm(request.POST)
        if form.is_valid():
            user_input = form.cleaned_data['user_input']
            recent_messages = session.messages.order_by('-created')[:3][::-1]  # 获取最近的三条消息
            ai_response = generate_response(user_input, recent_messages)

            Message.objects.create(session=session, sender='human', text=user_input)
            Message.objects.create(session=session, sender='ai', text=ai_response)

            return redirect('chats:chat', id=session.id)
    else:
        form = ChatForm()

    chat_history = session.messages.order_by('created')
    return render(request, 'chats/chat.html', {
        'form': form,
        'chat_history': chat_history,
        'session': session,
    })

请注意，这里只获取了最近的三条消息作为上下文。在实际应用中，你可以根据需要调整上下文的大小。获取更多的消息可以提高 大模型 的回复质量，但也会增加 API 请求的成本。

URL 配置：定义应用路由

URL 配置定义了应用的路由，将 URL 映射到相应的视图函数。

from django.urls import path
from .views import home, chat_view, new_chat

app_name = "chats"

urlpatterns = [
    path('', home, name='home'),
    path('new/', new_chat, name='new_chat'),
    path('<str:id>/', chat_view, name='chat'),
]

模板设计：呈现用户界面

模板负责呈现用户界面。base.html 定义了基本的 HTML 结构，包括导航栏和内容区域。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Chat App</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css" rel="stylesheet">
</head>
<body class="bg-light">
    <nav class="navbar navbar-expand-lg navbar-dark bg-dark mb-4">
        <div class="container">
        <h5 class="text-white">AI app</h5>
        </div>
    </nav>
    <div class="container">
        {% block content %}{% endblock %}
    </div>
</body>
</html>

home.html 渲染首页，提供一个开始新会话的链接。

{% extends 'base.html' %}

{% block content %}
<div class="container text-center mt-5">
  <h1 class="mb-4">Welcome to the Chat</h1>
  <a href="{% url 'chats:new_chat' %}" class="btn btn-primary btn-lg">Start New Chat</a>
</div>
{% endblock %}

chat.html 渲染聊天页面，显示聊天历史和输入表单。

{% extends "base.html" %}
{% load widget_tweaks %}
{% load markdownify %}

{% block title %}Chat{% endblock %}

{% block content %}
  <h2 class="mb-4">💬 Chat with AI</h2>

  <div class="mb-4 border rounded p-3 bg-white" style="height: 400px; overflow-y: auto;">
    {% for msg in chat_history %}
      <div class="mb-3">
        <span class="badge {% if msg.sender == 'human' %}bg-primary{% else %}bg-secondary{% endif %}">
          {{ msg.sender|capfirst }}
        </span>
        <div class="mt-1">{{ msg.text|markdownify }}</div>
      </div>
    {% empty %}
      <p class="text-muted">No messages yet.</p>
    {% endfor %}
  </div>

  <form method="post" class="card card-body shadow-sm">
    {% csrf_token %}
    <div class="mb-3">
      {{ form.user_input.label_tag }}
      {% render_field form.user_input class="form-control" placeholder="Type your message..." %}
    </div>
    <button type="submit" class="btn btn-primary">Send</button>
  </form>
{% endblock %}

widget_tweaks 用于更方便地控制表单字段的渲染，markdownify 用于将 Markdown 格式的文本渲染为 HTML。

深入讨论：性能优化与可扩展性

在实际部署中，我们需要考虑性能优化和可扩展性。以下是一些建议：

  • 缓存：可以使用 Django 的缓存框架缓存聊天历史，减少数据库查询次数。
  • 异步任务：可以使用 Celery 或 Redis Queue 将 AI 响应生成任务异步化，避免阻塞主线程。
  • 负载均衡：可以使用 Nginx 或 HAProxy 实现负载均衡，将请求分发到多个服务器上。
  • 数据库优化：可以使用数据库索引优化查询性能，并考虑使用读写分离策略。

此外，还可以考虑使用向量数据库来存储聊天历史的向量表示，以便进行更高级的语义搜索和推荐。 这将使得大模型可以更加高效地理解上下文。

结论：构建智能聊天应用的未来

通过本文的介绍，我们了解了如何使用 Django 和 LangChain 构建一个智能聊天应用，并集成了 OpenAI 的 GPT-4o-mini 模型。这个应用具有持久会话和智能回复功能，可以用于构建各种 AI 驱动的产品。随着 大模型 技术的不断发展，我们可以期待更多创新的应用场景。例如，可以将 大模型 用于客户服务，自动回答常见问题，或者用于教育领域，提供个性化的学习辅导。Django 框架的灵活性和 LangChain 的强大编排能力，为我们构建这些应用提供了坚实的基础。掌握这些技术，你就能在 大模型 时代抓住机遇，创造更大的价值。

By llmtrend

Related Post

LLM

构建 MCP 服务器：通往智能 AI 集成的指南

llmtrend
LLM

LangChain：模型、提示词与输出解析器，构建AI应用的基石

llmtrend
LLM

大模型赋能时序预测：TimeCAP开启全新时代

llmtrend

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

You Missed

Prompt

大模型 Prompt 工程的本质：从 “成为 (Be)” 到 “行动 (Do)” 的飞跃

LLM

构建 MCP 服务器：通往智能 AI 集成的指南

LLM

使用 Foundry Local 构建 Blazor 本地 AI 聊天应用：从 Ollama 到完全本地化

LLM

LangChain实战指南：基于Groq的极速LLM应用开发