开发环境搭建
工欲善其事，必先利其器。在正式开始 LangChain 的学习之前，我们需要先搭建一个高效的开发环境。一个好的开发环境不仅能让我们的编程过程更加便捷，还能避免很多不必要的技术问题。
2.1 Python 环境安装与配置
Python 是 LangChain 的主要开发语言，因此我们首先需要安装和配置 Python 环境。推荐使用 Python 3.8 及以上版本，以确保与 LangChain 的最佳兼容性。3SdhPNReyfSez0Q4gOc0v6ykW2hqke4CnFnKQxaIhL8=
安装 Python
不同操作系统的安装方式略有不同：
Windows 用户可以直接从 Python 官网下载安装包。在安装过程中，记得勾选"Add Python to PATH"选项，这样可以在命令行中直接使用 python 命令。3SdhPNReyfSez0Q4gOc0v6ykW2hqke4CnFnKQxaIhL8=
macOS 用户可以使用 Homebrew 进行安装：
bash
▼bash
复制代码brew install python3Linux 用户通常可以使用包管理器：cLGytfopnrFuxnn3sz+3dYGbZsmkbigItBfA6ZV7hZU=
bash
▼bash复制代码# Ubuntu/Debian
sudo apt update
sudo apt install python3 python3-pip
# CentOS/RHEL
sudo yum install python3 python3-pip验证安装
安装完成后，打开终端或命令提示符，输入以下命令验证安装是否成功：7QiJ3WkhTRjV8VSaIHYq0+Wzni+Hi3xtR8CR8/IP1VI=
bash
▼bash复制代码python --version
pip --version这段程序输出结果：
plain
▼plain复制代码Python 3.9.7
pip 21.2.4 from /usr/local/lib/python3.9/site-packages/pip (python 3.9)配置虚拟环境
为了避免不同项目之间的依赖冲突，强烈推荐使用虚拟环境。Python 提供了内置的 venv 模块来创建虚拟环境：
bash
▼bash复制代码# 创建虚拟环境
python -m venv langchain_env
# 激活虚拟环境
# Windows
langchain_env\Scripts\activate
# macOS/Linux
source langchain_env/bin/activate
# 确认虚拟环境已激活
which python激活虚拟环境后，命令行提示符前会出现虚拟环境的名称，表示当前处于虚拟环境中。
2.2 LangChain 库安装
在配置好基础 Python 环境后，我们需要安装 LangChain 库及其相关依赖。7QiJ3WkhTRjV8VSaIHYq0+Wzni+Hi3xtR8CR8/IP1VI=
安装核心库
使用 pip 安装 LangChain 的核心库：
bash
▼bash复制代码pip install langchain
pip install langchain-community
pip install langchain-core安装模型相关依赖
由于我们将使用通义千问模型，需要安装阿里云的 SDK：
bash
▼bash
复制代码pip install dashscope验证安装
创建一个简单的测试脚本来验证 LangChain 是否安装成功：
python
▼python复制代码# test_langchain.py
from langchain_core.messages import HumanMessage
from langchain_community.chat_models import ChatTongyi
import os
# 设置环境变量（请替换为你的实际 API Key）
os.environ["DASHSCOPE_API_KEY"] = "your_api_key_here"
def test_langchain_installation():
"""测试 LangChain 安装是否成功"""
try:
# 初始化通义千问模型
llm = ChatTongyi(model="qwen-plus")
# 创建一个简单的消息
messages = [HumanMessage(content="你好，我是程序员鱼皮，请简单介绍一下 LangChain")]
# 测试调用（这里只是验证代码结构，实际需要有效的 API Key）
print("LangChain 安装成功！")
print("环境配置完成，可以开始开发了！")
except ImportError as e:
print(f"导入错误：{e}")
print("请检查 LangChain 是否正确安装")
except Exception as e:
print(f"其他错误：{e}")
print("请检查网络连接和 API Key 配置")
if __name__ == "__main__":
test_langchain_installation()2.3 Java 环境配置(用于 LangChain4j)
LangChain4j 是 LangChain 的 Java 版本实现，为 Java 开发者提供了熟悉的编程体验。
安装 Java JDK
LangChain4j 需要 Java 11 或更高版本。推荐使用 OpenJDK：
下载安装：
- 访问 OpenJDK 官网下载适合你操作系统的版本
- 或者使用包管理器安装：
bash
▼bash复制代码# Windows (使用 Chocolatey)
choco install openjdk11
# macOS (使用 Homebrew)
brew install openjdk@11
# Ubuntu/Debian
sudo apt install openjdk-11-jdk
# CentOS/RHEL
sudo yum install java-11-openjdk-devel配置环境变量
安装完成后，需要配置 JAVA_HOME 环境变量：Iy8qa2Wkgy1zjaDf5wVYJsxIyeHLdZx9B8sLhGVCeeI=
Windows：
bash
▼bash复制代码setx JAVA_HOME "C:\Program Files\Java\jdk-11.0.x"
setx PATH "%PATH%;%JAVA_HOME%\bin"macOS/Linux：TRQG02HuvSbBCdyta/9OfF/iMg4d5URNJyKR3KkD/fE=
bash
▼bash复制代码export JAVA_HOME=/usr/lib/jvm/java-11-openjdk
export PATH=$PATH:$JAVA_HOME/bin验证 Java 安装
bash
▼bash复制代码java -version
javac -version这段程序输出结果：
plain
▼plain复制代码java version "11.0.12" 2021-07-20 LTS
Java(TM) SE Runtime Environment 18.9 (build 11.0.12+8-LTS-237)
Java HotSpot(TM) 64-Bit Server VM 18.9 (build 11.0.12+8-LTS-237, mixed mode)
javac 11.0.12Maven 或 Gradle 配置
对于 Java 项目，我们还需要配置构建工具。以 Maven 为例：
安装 Maven：
bash
▼bash复制代码# Windows (使用 Chocolatey)
choco install maven
# macOS (使用 Homebrew)
brew install maven
# Ubuntu/Debian
sudo apt install maven创建基础项目结构：
xml
▼xml复制代码<!-- pom.xml -->
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>cn.codefather</groupId>
<artifactId>langchain4j-demo</artifactId>
<version>1.0.0</version>
<properties>
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<!-- https://mvnrepository.com/artifact/dev.langchain4j/langchain4j-community-dashscope -->
<dependency>
<groupId>dev.langchain4j</groupId>
<artifactId>langchain4j-community-dashscope</artifactId>
<version>1.0.0-beta2</version>
</dependency>
</dependencies>
</project>一个 LangChain4j 的典型使用示例：TRQG02HuvSbBCdyta/9OfF/iMg4d5URNJyKR3KkD/fE=
参考 官方文档 来编写示例对话代码，创建了一个 ChatModel 并调用：
java
▼java复制代码public class LangChainAiInvoke {
public static void main(String[] args) {
ChatLanguageModel qwenModel = QwenChatModel.builder()
.apiKey(TestApiKey.API_KEY)
.modelName("qwen-max")
.build();
String answer = qwenModel.chat("我是程序员鱼皮，这是编程导航 codefather.cn 的原创项目教程");
System.out.println(answer);
}
}2.4 开发工具选择与配置
选择合适的开发工具能显著提升开发效率。这里介绍几种主流的开发工具配置。
Visual Studio Code 配置
VS Code 是轻量级但功能强大的编辑器，特别适合 Python 开发：3SdhPNReyfSez0Q4gOc0v6ykW2hqke4CnFnKQxaIhL8=
必装插件：
- Python：提供 Python 语法高亮和调试支持
- Pylance：微软官方的 Python 语言服务器
- Jupyter：支持 Jupyter Notebook
- GitLens：增强 Git 功能
配置 Python 解释器：HrGXUqFhjK7wNHkLfEF5cglTdzhFLxXIforC6kfYOak=
- 打开 VS Code，按
Ctrl+Shift+P打开命令面板 - 输入 "Python: Select Interpreter"
- 选择你创建的虚拟环境中的 Python 解释器
工作区配置示例：
json
▼json复制代码{
"python.defaultInterpreterPath": "./langchain_env/bin/python",
"python.linting.enabled": true,
"python.linting.pylintEnabled": true,
"python.formatting.provider": "black",
"editor.formatOnSave": true
}IntelliJ IDEA 配置
对于 Java 开发，IntelliJ IDEA 是最佳选择：
创建新项目：Iy8qa2Wkgy1zjaDf5wVYJsxIyeHLdZx9B8sLhGVCeeI=
- 选择 "New Project"
- 选择 "Maven" 或 "Gradle"
- 配置项目 SDK 为 Java 11+
- 设置 GroupId 为
cn.codefather，ArtifactId 为langchain4j-demo
推荐插件：
- Lombok：简化 Java 代码
- Maven Helper：Maven 依赖管理
- GitToolBox：Git 集成增强
Jupyter Notebook 配置
Jupyter Notebook 特别适合数据科学和原型开发：
bash
▼bash复制代码# 在虚拟环境中安装 Jupyter
pip install jupyter notebook jupyterlab
# 启动 Jupyter Notebook
jupyter notebook
# 或者启动 JupyterLab（推荐）
jupyter lab配置内核：
bash
▼bash复制代码# 将虚拟环境添加到 Jupyter 内核
python -m ipykernel install --user --name=langchain_env --display-name="Python (LangChain)"示例 Notebook 单元格：Iy8qa2Wkgy1zjaDf5wVYJsxIyeHLdZx9B8sLhGVCeeI=
python
▼python复制代码# 测试 LangChain 环境
import langchain
from langchain_alibaba_cloud import ChatTongyi
print(f"LangChain 版本：{langchain.__version__}")
print("环境配置成功！准备开始编程导航的 LangChain 学习之旅！")2.5 调试与测试环境准备
良好的调试和测试环境是高质量代码的保障。 nqebE0GbQps0Ats4MKJjbVHQiAAW+ffJdMrCsN5dgzs=
Python 调试配置
VS Code 调试配置：
创建 .vscode/launch.json 文件：Iy8qa2Wkgy1zjaDf5wVYJsxIyeHLdZx9B8sLhGVCeeI=
json
▼json复制代码{
"version": "0.2.0",
"configurations": [
{
"name": "Python: Current File",
"type": "python",
"request": "launch",
"program": "${file}",
"console": "integratedTerminal",
"envFile": "${workspaceFolder}/.env"
}
]
}创建 .env 文件：
bash
▼bash复制代码# .env
DASHSCOPE_API_KEY=your_api_key_here
LANGCHAIN_TRACING_V2=true
LANGCHAIN_API_KEY=your_langchain_api_key测试框架配置
安装常用的测试库：
bash
▼bash复制代码pip install pytest pytest-asyncio pytest-mock
pip install unittest-xml-reporting # 用于生成测试报告创建测试示例：
python
▼python复制代码# tests/test_langchain_basic.py
import pytest
from langchain_community.chat_models import ChatTongyi
from langchain_core.messages import HumanMessage
import os
os.environ["DASHSCOPE_API_KEY"] = "sk-xxxxxx" # 替换为你的真实 API Key
class TestLangChainBasic:
"""LangChain 基础功能测试"""
def setup_method(self):
"""每个测试方法执行前的设置"""
self.api_key = os.getenv("DASHSCOPE_API_KEY")
if not self.api_key:
pytest.skip("需要配置 DASHSCOPE_API_KEY 环境变量")
def test_chat_tongyi_initialization(self):
"""测试通义千问模型初始化"""
llm = ChatTongyi(model="qwen-plus", api_key=self.api_key)
assert llm is not None
assert llm.model_name == "qwen-plus"
@pytest.mark.asyncio
async def test_simple_chat(self):
"""测试简单对话功能"""
llm = ChatTongyi(model="qwen-plus", api_key=self.api_key)
messages = [HumanMessage(content="你好")]
# 这里只是测试结构，实际测试需要有效的 API
# response = await llm.ainvoke(messages)
# assert response is not None
pass
if __name__ == "__main__":
# 运行测试
pytest.main([__file__, "-v"])Java 调试配置
IntelliJ IDEA 调试：
- 在代码行左侧点击设置断点
- 右键选择 "Debug" 运行程序
- 使用调试工具栏控制程序执行
Maven 测试配置：85OwC9dA70cYmJ5h6K5cNTXdNAq0qMRNbG9wTf+m4FU=
xml
▼xml复制代码<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>3.0.0-M7</version>
</plugin>
</plugins>
</build>2.6 常见环境问题解决方案
在环境搭建过程中，可能会遇到各种问题。这里总结一些常见问题及其解决方案 Iy8qa2Wkgy1zjaDf5wVYJsxIyeHLdZx9B8sLhGVCeeI=
Python 相关问题
问题 1：pip 安装速度慢
bash
▼bash复制代码# 使用国内镜像源
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple/ langchain
# 或者永久配置镜像源
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple/问题 2：虚拟环境无法激活
bash
▼bash复制代码# Windows PowerShell 执行策略问题
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
# 然后重新激活虚拟环境
langchain_env\Scripts\activate问题 3：模块导入失败HrGXUqFhjK7wNHkLfEF5cglTdzhFLxXIforC6kfYOak=
python
▼python复制代码# 检查 Python 路径
import sys
print(sys.path)
# 添加当前目录到 Python 路径
import sys
import os
sys.path.append(os.getcwd())LangChain 相关问题
问题 1：API Key 配置问题7QiJ3WkhTRjV8VSaIHYq0+Wzni+Hi3xtR8CR8/IP1VI=
python
▼python复制代码# 多种方式配置 API Key
import os
# 方式1：环境变量
os.environ["DASHSCOPE_API_KEY"] = "your_key"
# 方式2：直接传参
from langchain_community.chat_models import ChatTongyi
llm = ChatTongyi(model="qwen-plus", dashscope_api_key="your_key")
# 方式3：从配置文件读取
import json
with open('config.json', 'r') as f:
config = json.load(f)
api_key = config.get('dashscope_api_key')问题 2：网络连接问题
python
▼python复制代码# 设置代理（如果需要）
import os
os.environ["http_proxy"] = "http://proxy.example.com:8080"
os.environ["https_proxy"] = "http://proxy.example.com:8080"
# 设置超时时间
from langchain_alibaba_cloud import ChatTongyi
llm = ChatTongyi(
model="qwen-plus",
timeout=60 # 60秒超时
)Java 相关问题
问题 1：JDK 版本不兼容
bash
▼bash复制代码# 检查 Java 版本
java -version
# 如果版本过低，升级到 Java 11+
# 使用 SDKMAN 管理多个 Java 版本
curl -s "https://get.sdkman.io" | bash
sdk install java 11.0.12-open
sdk use java 11.0.12-open问题 2：Maven 依赖下载失败
xml
▼xml复制代码<!-- 配置国内镜像仓库 -->
<repositories>
<repository>
<id>aliyun</id>
<url>https://maven.aliyun.com/repository/public</url>
</repository>
</repositories>快速诊断脚本：7QiJ3WkhTRjV8VSaIHYq0+Wzni+Hi3xtR8CR8/IP1VI=
python
▼python复制代码# env_check.py - 环境检查脚本
import sys
import subprocess
import importlib
def check_python_version():
"""检查 Python 版本"""
version = sys.version_info
if version.major == 3 and version.minor >= 8:
print(f"✅ Python 版本: {version.major}.{version.minor}.{version.micro}")
return True
else:
print(f"❌ Python 版本过低: {version.major}.{version.minor}.{version.micro}")
return False
def check_package(package_name):
"""检查包是否安装"""
try:
importlib.import_module(package_name)
print(f"✅ {package_name} 已安装")
return True
except ImportError:
print(f"❌ {package_name} 未安装")
return False
def check_environment():
"""环境检查主函数"""
print("=== LangChain 开发环境检查 ===")
# 检查 Python 版本
python_ok = check_python_version()
# 检查必要的包
packages = [
'langchain',
'langchain_core',
'langchain_community',
'dashscope'
]
all_packages_ok = all(check_package(pkg) for pkg in packages)
# 检查环境变量
import os
api_key = os.getenv('DASHSCOPE_API_KEY')
if api_key:
print("✅ DASHSCOPE_API_KEY 已配置")
else:
print("⚠️ DASHSCOPE_API_KEY 未配置")
# 总结
if python_ok and all_packages_ok:
print("\n🎉 环境配置完成！可以开始 LangChain 开发了！")
print("欢迎来到编程导航的 LangChain 学习之旅！")
else:
print("\n❌ 环境配置存在问题，请根据上面的提示进行修复")
if __name__ == "__main__":
check_environment()通过本章的学习，我们已经成功搭建了完整的 LangChain 开发环境。这个环境将是我们后续学习和开发的基础。记住，环境配置虽然可能有些繁琐，但这是开发前必须要做的事情。
练习题
练习题 1
编写一个环境检测脚本，自动检查当前系统是否满足 LangChain 开发的所有要求，包括 Python 版本、必要的库安装情况以及 API Key 配置状态。
参考答案：85OwC9dA70cYmJ5h6K5cNTXdNAq0qMRNbG9wTf+m4FU=
python
▼python复制代码import sys
import subprocess
import os
import importlib.util
def check_python_version():
version = sys.version_info
required_major, required_minor = 3, 8
if version.major > required_major or (version.major == required_major and version.minor >= required_minor):
print(f"✅ Python 版本符合要求: {version.major}.{version.minor}.{version.micro}")
return True
else:
print(f"❌ Python 版本不符合要求: {version.major}.{version.minor}.{version.micro} (需要 >= 3.8)")
return False
def check_package_installed(package_name):
spec = importlib.util.find_spec(package_name)
return spec is not None
def check_environment_complete():
print("=== 编程导航 LangChain 环境检测工具 ===\n")
all_good = True
# 检查 Python 版本
if not check_python_version():
all_good = False
# 检查必要包
required_packages = [
'langchain', 'langchain_core', 'langchain_community',
'dashscope'
]
print("\n📦 检查必要的 Python 包:")
for package in required_packages:
if check_package_installed(package):
print(f"✅ {package}")
else:
print(f"❌ {package} (请运行: pip install {package})")
all_good = False
# 检查环境变量
print("\n🔑 检查环境变量:")
api_key = os.getenv('DASHSCOPE_API_KEY')
if api_key and len(api_key) > 10:
print("✅ DASHSCOPE_API_KEY 已正确配置")
else:
print("❌ DASHSCOPE_API_KEY 未配置或配置错误")
all_good = False
# 最终结果
print("\n" + "="*50)
if all_good:
print("🎉 恭喜！您的环境配置完美，可以开始 LangChain 学习之旅！")
else:
print("⚠️ 环境存在问题，请根据上述提示进行修复后再试")
return all_good
if __name__ == "__main__":
check_environment_complete()练习题 2
创建一个简单的 LangChain 应用，使用通义千问模型实现一个"编程导航助手"，能够回答关于编程学习的问题。要求包含错误处理和日志记录功能。Iy8qa2Wkgy1zjaDf5wVYJsxIyeHLdZx9B8sLhGVCeeI=
参考答案：
python
▼python复制代码import os
import logging
from datetime import datetime
from langchain_community.chat_models import ChatTongyi
from langchain_core.messages import HumanMessage, SystemMessage
from langchain_core.prompts import ChatPromptTemplate
os.environ["DASHSCOPE_API_KEY"] = "sk-xxxxx" # 替换为你的真实 API Key
class ProgrammingNavigatorAssistant:
def __init__(self, api_key=None):
"""初始化编程导航助手"""
# 配置日志
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(levelname)s - %(message)s',
handlers=[
logging.FileHandler('navigator_assistant.log'),
logging.StreamHandler()
]
)
self.logger = logging.getLogger(__name__)
# 设置 API Key
self.api_key = api_key or os.getenv('DASHSCOPE_API_KEY')
if not self.api_key:
raise ValueError("请设置 DASHSCOPE_API_KEY 环境变量或传入 api_key 参数")
# 初始化模型
try:
self.llm = ChatTongyi(
model="qwen-plus",
dashscope_api_key=self.api_key,
temperature=0.7
)
self.logger.info("编程导航助手初始化成功")
except Exception as e:
self.logger.error(f"模型初始化失败: {e}")
raise
# 设置系统提示
self.system_prompt = """你是编程导航(codefather.cn)的专业编程学习助手。
你的任务是帮助用户解答编程学习相关的问题，提供实用的学习建议和技术指导。
请用温暖、专业且友好的语调回答问题。"""
def ask_question(self, question):
"""向助手提问"""
try:
self.logger.info(f"收到用户问题: {question}")
# 构建消息
messages = [
SystemMessage(content=self.system_prompt),
HumanMessage(content=question)
]
# 调用模型
response = self.llm.invoke(messages)
answer = response.content
self.logger.info("问题回答成功")
return answer
except Exception as e:
error_msg = f"回答问题时发生错误: {e}"
self.logger.error(error_msg)
return f"抱歉，我现在无法回答您的问题。错误信息：{error_msg}"
def chat_session(self):
"""开始聊天会话"""
print("🤖 编程导航助手启动成功！")
print("我是您的专属编程学习伙伴，可以帮您解答编程相关问题。")
print("输入 'quit' 或 'exit' 退出聊天\n")
while True:
try:
user_input = input("👤 您的问题: ").strip()
if user_input.lower() in ['quit', 'exit', '退出']:
print("👋 感谢使用编程导航助手，祝您学习愉快！")
break
if not user_input:
print("请输入您的问题~")
continue
print("🤖 正在思考...")
answer = self.ask_question(user_input)
print(f"🤖 助手回答: {answer}\n")
except KeyboardInterrupt:
print("\n👋 感谢使用编程导航助手！")
break
except Exception as e:
print(f"❌ 发生错误: {e}")
def main():
"""主函数"""
try:
# 创建助手实例
assistant = ProgrammingNavigatorAssistant()
# 测试单次问答
test_question = "我想学习 Python，应该从哪里开始？"
print("=== 测试问答 ===")
print(f"问题: {test_question}")
answer = assistant.ask_question(test_question)
print(f"回答: {answer}")
# 开始交互式聊天
print("\n=== 开始聊天会话 ===")
assistant.chat_session()
except Exception as e:
print(f"程序启动失败: {e}")
if __name__ == "__main__":
main()练习题 3
设计一个自动化的开发环境部署脚本，能够在新的机器上一键安装和配置完整的 LangChain 开发环境（包括 Python、Java、必要的库和开发工具）。脚本应该支持不同的操作系统。
参考答案：
python
▼python复制代码#!/usr/bin/env python3
"""
编程导航 LangChain 开发环境自动部署脚本
支持 Windows、macOS、Linux 系统
"""
import os
import sys
import subprocess
import platform
import shutil
from pathlib import Path
class EnvironmentDeployer:
def __init__(self):
self.system = platform.system().lower()
self.python_version = "3.9"
self.java_version = "11"
self.project_name = "langchain_env"
print(f"🚀 编程导航 LangChain 环境部署工具")
print(f"📋 检测到系统: {platform.system()} {platform.release()}")
print(f"🎯 将安装 Python {self.python_version} 和 Java {self.java_version}")
def run_command(self, command, shell=True):
"""执行系统命令"""
try:
print(f"🔧 执行命令: {command}")
result = subprocess.run(command, shell=shell, capture_output=True, text=True)
if result.returncode == 0:
print(f"✅ 命令执行成功")
return True, result.stdout
else:
print(f"❌ 命令执行失败: {result.stderr}")
return False, result.stderr
except Exception as e:
print(f"❌ 命令执行异常: {e}")
return False, str(e)
def check_command_exists(self, command):
"""检查命令是否存在"""
return shutil.which(command) is not None
def install_python(self):
"""安装 Python"""
print("\n🐍 安装 Python...")
if self.check_command_exists("python3"):
print("✅ Python 已安装")
return True
if self.system == "windows":
print("请手动从 https://www.python.org/ 下载并安装 Python")
return False
elif self.system == "darwin": # macOS
if self.check_command_exists("brew"):
return self.run_command(f"brew install python@{self.python_version}")[0]
else:
print(
"请先安装 Homebrew: /bin/bash -c \"$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)\"")
return False
elif self.system == "linux":
# 尝试不同的包管理器
if self.check_command_exists("apt"):
return self.run_command("sudo apt update && sudo apt install -y python3 python3-pip python3-venv")[0]
elif self.check_command_exists("yum"):
return self.run_command("sudo yum install -y python3 python3-pip")[0]
elif self.check_command_exists("dnf"):
return self.run_command("sudo dnf install -y python3 python3-pip")[0]
return False
def install_java(self):
"""安装 Java"""
print("\n☕ 安装 Java...")
if self.check_command_exists("java"):
print("✅ Java 已安装")
return True
if self.system == "windows":
print("请手动从 https://adoptopenjdk.net/ 下载并安装 OpenJDK 11")
return False
elif self.system == "darwin": # macOS
if self.check_command_exists("brew"):
return self.run_command(f"brew install openjdk@{self.java_version}")[0]
elif self.system == "linux":
if self.check_command_exists("apt"):
return self.run_command(f"sudo apt install -y openjdk-{self.java_version}-jdk")[0]
elif self.check_command_exists("yum"):
return self.run_command(f"sudo yum install -y java-{self.java_version}-openjdk-devel")[0]
return False
def create_virtual_environment(self):
"""创建 Python 虚拟环境"""
print(f"\n🌍 创建虚拟环境 {self.project_name}...")
venv_path = Path.home() / self.project_name
if venv_path.exists():
print(f"⚠️ 虚拟环境 {venv_path} 已存在")
return True
success, _ = self.run_command(f"python3 -m venv {venv_path}")
if success:
print(f"✅ 虚拟环境创建成功: {venv_path}")
return True
return False
def install_langchain_packages(self):
"""安装 LangChain 相关包"""
print("\n📦 安装 LangChain 包...")
venv_path = Path.home() / self.project_name
# 根据系统确定激活脚本路径
if self.system == "windows":
activate_script = venv_path / "Scripts" / "activate"
pip_cmd = f"{venv_path}\\Scripts\\pip"
else:
activate_script = venv_path / "bin" / "activate"
pip_cmd = f"{venv_path}/bin/pip"
packages = [
"langchain",
"langchain-core",
"langchain-community",
"dashscope",
"jupyter",
"pytest",
"black",
"pylint"
]
for package in packages:
print(f"📦 安装 {package}...")
success, _ = self.run_command(f"{pip_cmd} install {package}")
if not success:
print(f"❌ {package} 安装失败")
return False
print("✅ 所有 LangChain 包安装完成")
return True
def create_project_structure(self):
"""创建项目结构"""
print("\n📁 创建项目结构...")
project_dir = Path.home() / "langchain_projects"
project_dir.mkdir(exist_ok=True)
# 创建示例项目
demo_dir = project_dir / "demo"
demo_dir.mkdir(exist_ok=True)
# 创建示例文件
demo_file = demo_dir / "hello_langchain.py"
demo_content = '''"""
编程导航 LangChain 示例项目
"""
import os
from langchain_community.chat_models import ChatTongyi
from langchain_core.messages import HumanMessage
def main():
# 设置 API Key（请替换为您的实际 API Key）
api_key = os.getenv("DASHSCOPE_API_KEY")
if not api_key:
print("请设置 DASHSCOPE_API_KEY 环境变量")
return
# 初始化模型
llm = ChatTongyi(model="qwen-plus", dashscope_api_key=api_key)
# 发送消息
messages = [HumanMessage(content="你好，我是编程导航的学员！")]
response = llm.invoke(messages)
print(f"AI 回复: {response.content}")
if __name__ == "__main__":
main()
'''
with open(demo_file, 'w', encoding='utf-8') as f:
f.write(demo_content)
# 创建环境配置文件
env_file = demo_dir / ".env.example"
env_content = '''# 阿里云通义千问 API Key
DASHSCOPE_API_KEY=your_api_key_here
# LangChain 跟踪配置（可选）
LANGCHAIN_TRACING_V2=true
LANGCHAIN_API_KEY=your_langchain_api_key
'''
with open(env_file, 'w', encoding='utf-8') as f:
f.write(env_content)
print(f"✅ 项目结构创建完成: {project_dir}")
return True
def deploy(self):
"""执行完整部署"""
print("🚀 开始部署 LangChain 开发环境...\n")
steps = [
("安装 Python", self.install_python),
("安装 Java", self.install_java),
("创建虚拟环境", self.create_virtual_environment),
("安装 LangChain 包", self.install_langchain_packages),
("创建项目结构", self.create_project_structure),
]
for step_name, step_func in steps:
print(f"\n{'=' * 50}")
print(f"📋 步骤: {step_name}")
print('=' * 50)
if not step_func():
print(f"❌ {step_name} 失败，部署终止")
return False
self.print_completion_info()
return True
def print_completion_info(self):
"""打印完成信息"""
venv_path = Path.home() / self.project_name
project_path = Path.home() / "langchain_projects"
activation_cmd = {
'windows': f"{venv_path}\\Scripts\\activate",
'darwin': f"source {venv_path}/bin/activate",
'linux': f"source {venv_path}/bin/activate"
}.get(self.system, f"source {venv_path}/bin/activate")
print(f"\n{'=' * 60}")
print("🎉 LangChain 开发环境部署完成！")
print('=' * 60)
print(f"📂 虚拟环境位置: {venv_path}")
print(f"📂 项目目录: {project_path}")
print(f"\n🔧 激活虚拟环境:")
print(f" {activation_cmd}")
print(f"\n📝 下一步:")
print(f" 1. 激活虚拟环境")
print(f" 2. 配置 .env 文件中的 API Key")
print(f" 3. 运行示例: python {project_path}/demo/hello_langchain.py")
print(f"\n🌟 欢迎来到编程导航的 LangChain 学习之旅！")
print(f"📚 更多教程请访问: https://www.codefather.cn/")
def main():
"""主函数"""
try:
deployer = EnvironmentDeployer()
success = deployer.deploy()
if success:
print("\n✅ 部署成功完成！")
else:
print("\n❌ 部署过程中遇到问题，请检查错误信息")
except KeyboardInterrupt:
print("\n⚠️ 部署被用户中断")
except Exception as e:
print(f"\n❌ 部署过程中发生未预期的错误: {e}")
if __name__ == "__main__":
main()至此，我们已经完成了第2章的全部内容。通过这章的学习，你已经具备了完整的 LangChain 开发环境，包括 Python 和 Java 两个语言的支持。这个坚实的基础将支撑你在后续章节中探索 LangChain 的强大功能。