高级java每日一道面试题-2025年6月23日-基础篇[LangChain4j]-请解释 LangChain4j 的核心架构设计理念，与 LangChain (Python) 有什么本质区别？

LangChain4j 核心架构设计理念详解

一、LangChain4j 整体架构设计

1.1 分层架构设计理念

┌─────────────────────────────────────────────────────────┐
│ 应用层 (Application) │
├─────────────────────────────────────────────────────────┤
│ 链与代理层 (Chains & Agents) │
├─────────────────────────────────────────────────────────┤
│ 组件层 (Components: Memory, Tools, etc.) │
├─────────────────────────────────────────────────────────┤
│ 核心抽象层 (Core Abstractions: LLM, Embedding) │
├─────────────────────────────────────────────────────────┤
│ 服务提供层 (Service Providers: OpenAI, etc.) │
├─────────────────────────────────────────────────────────┤
│ 基础设施层 (Infrastructure: HTTP, JSON) │
└─────────────────────────────────────────────────────────┘

1.2 核心设计原则

/**
* LangChain4j 核心设计原则实现示例
*/
public class LangChain4jDesignPrinciples {

// 原则1：类型安全（Type Safety）
public static class TypeSafetyExample {
// Java 强类型系统确保编译时类型检查
public <T extends LanguageModel> T createModel(Class<T> modelClass) {
// 避免Python中的运行时类型错误
return modelClass.getDeclaredConstructor().newInstance();
}

// 泛型确保链式调用类型安全
public <I, O> Chain<I, O> createChain(Transformer<I, O> transformer) {
return Chain.of(transformer);
}
}

// 原则2：不可变性（Immutability）
@Immutable
public static class ChatMessage {
private final String role;
private final String content;
private final Instant timestamp;

public ChatMessage(String role, String content) {
this.role = role;
this.content = content;
this.timestamp = Instant.now();
}

// 没有setter，只有getter
public String getRole() { return role; }
public String getContent() { return content; }

// 返回新实例而不是修改现有实例
public ChatMessage withContent(String newContent) {
return new ChatMessage(this.role, newContent);
}
}

// 原则3：声明式配置（Declarative Configuration）
@ConfigurationProperties(prefix = "langchain4j")
public static class LangChain4jConfig {
private String openAiApiKey;
private String modelName = "gpt-3.5-turbo";
private double temperature = 0.7;
private Duration timeout = Duration.ofSeconds(60);

// 自动绑定配置
// @Configuration + @Bean 提供类型安全的依赖注入
}

// 原则4：响应式编程支持（Reactive Programming）
public static class ReactiveExample {
public Flux<ChatMessage> streamChatCompletion(ChatLanguageModel model,
String userMessage) {
return model.generate(userMessage)
.map(response -> new ChatMessage("assistant", response))
.delayElements(Duration.ofMillis(100));
}
}
}

二、LangChain4j 核心组件详细设计

2.1 LLM 抽象层设计

/**
* LLM 核心抽象层设计
*/
public interface LanguageModel {

// 同步生成
String generate(String prompt);

// 异步生成
CompletableFuture<String> generateAsync(String prompt);

// 流式生成
Stream<String> generateStream(String prompt);

// 带参数的生成
String generate(String prompt, GenerationParameters parameters);
}

/**
* 聊天模型抽象
*/
public interface ChatLanguageModel extends LanguageModel {

// 消息历史管理
List<ChatMessage> getHistory();

// 带上下文的聊天
String chat(List<ChatMessage> messages);

// 工具调用支持
ChatResponse chatWithTools(List<ChatMessage> messages,
List<ToolSpecification> tools);
}

/**
* 嵌入式模型抽象
*/
public interface EmbeddingModel {

// 单文本嵌入
Embedding embed(String text);

// 批量嵌入
List<Embedding> embedAll(List<String> texts);

// 维度信息
int dimension();
}

/**
* 具体实现示例 – OpenAI
*/
@Service
public class OpenAiChatModel implements ChatLanguageModel {

private final OpenAiClient client;
private final Gson gson;
private final RateLimiter rateLimiter;

// 构造函数注入 – 依赖倒置原则
@Autowired
public OpenAiChatModel(OpenAiClient client,
@Qualifier("langchainGson") Gson gson,
RateLimiter rateLimiter) {
this.client = client;
this.gson = gson;
this.rateLimiter = rateLimiter;
}

@Override
public String generate(String prompt) {
// 使用组合模式而不是继承
return executeWithRetry(() -> {
OpenAiRequest request = buildRequest(prompt);
OpenAiResponse response = client.chat(request);
return extractContent(response);
});
}

@Override
public Stream<String> generateStream(String prompt) {
return Stream.generate(() -> {
// 流式响应处理
return processStreamResponse();
});
}

private String executeWithRetry(Supplier<String> operation) {
// 重试机制
return RetryUtils.retry(operation, 3, Duration.ofSeconds(2));
}
}

2.2 链（Chain）设计模式

/**
* 链的抽象定义
*/
public interface Chain<I, O> {

O execute(I input);

default <R> Chain<I, R> andThen(Chain<O, R> next) {
return input -> next.execute(this.execute(input));
}

static <I, O> Chain<I, O> of(Function<I, O> function) {
return function::apply;
}
}

/**
* 具体链实现
*/
@Component
public class ConversationalChain implements Chain<String, String> {

private final ChatLanguageModel model;
private final Memory memory;
private final List<Transformer<String, String>> preprocessors;
private final List<Transformer<String, String>> postprocessors;

// 建造者模式
public static class Builder {
private ChatLanguageModel model;
private Memory memory = new SimpleMemory();
private List<Transformer<String, String>> preprocessors = new ArrayList<>();
private List<Transformer<String, String>> postprocessors = new ArrayList<>();

public Builder withModel(ChatLanguageModel model) {
this.model = model;
return this;
}

public Builder withMemory(Memory memory) {
this.memory = memory;
return this;
}

public Builder addPreprocessor(Transformer<String, String> preprocessor) {
this.preprocessors.add(preprocessor);
return this;
}

public ConversationalChain build() {
return new ConversationalChain(this);
}
}

private ConversationalChain(Builder builder) {
this.model = builder.model;
this.memory = builder.memory;
this.preprocessors = builder.preprocessors;
this.postprocessors = builder.postprocessors;
}

@Override
public String execute(String userInput) {
// 预处理
String processedInput = preprocessors.stream()
.reduce(Function.identity(),
(f1, f2) -> f1.andThen(f2),
Function::identity)
.apply(userInput);

// 获取历史
List<ChatMessage> history = memory.getMessages();
List<ChatMessage> messages = new ArrayList<>(history);
messages.add(new UserMessage(processedInput));

// 调用模型
String response = model.chat(messages);

// 后处理
String processedResponse = postprocessors.stream()
.reduce(Function.identity(),
(f1, f2) -> f1.andThen(f2),
Function::identity)
.apply(response);

// 保存到记忆
memory.add(new UserMessage(processedInput));
memory.add(new AssistantMessage(processedResponse));

return processedResponse;
}
}

/**
* 复杂链组合示例
*/
@Service
public class DocumentQaChain implements Chain<String, String> {

private final EmbeddingModel embeddingModel;
private final VectorStore vectorStore;
private final ChatLanguageModel chatModel;
private final PromptTemplate promptTemplate;

public DocumentQaChain(EmbeddingModel embeddingModel,
VectorStore vectorStore,
ChatLanguageModel chatModel) {
this.embeddingModel = embeddingModel;
this.vectorStore = vectorStore;
this.chatModel = chatModel;
this.promptTemplate = new PromptTemplate(
"基于以下上下文回答问题：\\n\\n上下文：{context}\\n\\n问题：{question}\\n\\n答案："
);
}

@Override
public String execute(String question) {
// 1. 问题嵌入
Embedding questionEmbedding = embeddingModel.embed(question);

// 2. 向量检索
List<TextSegment> relevantSegments = vectorStore.findRelevant(questionEmbedding, 5);

// 3. 上下文构建
String context = relevantSegments.stream()
.map(TextSegment::text)
.collect(Collectors.joining("\\n\\n"));

// 4. 提示词填充
String prompt = promptTemplate.apply(
Map.of("context", context, "question", question)
);

// 5. 生成答案
return chatModel.generate(prompt);
}
}

2.3 内存（Memory）系统设计

/**
* 内存抽象接口
*/
public interface Memory {

void add(ChatMessage message);

List<ChatMessage> getMessages();

List<ChatMessage> getMessages(int limit);

void clear();

default boolean isEmpty() {
return getMessages().isEmpty();
}
}

/**
* 不同类型的内存实现
*/
public class MemorySystemDesign {

// 1. 基于窗口的内存
@Component
@Scope("session") // 支持会话作用域
public static class WindowMemory implements Memory {
private final Deque<ChatMessage> messages;
private final int windowSize;

public WindowMemory(@Value("${memory.window.size:10}") int windowSize) {
this.windowSize = windowSize;
this.messages = new ArrayDeque<>(windowSize);
}

@Override
public synchronized void add(ChatMessage message) {
if (messages.size() >= windowSize) {
messages.removeFirst();
}
messages.addLast(message);
}

@Override
public List<ChatMessage> getMessages() {
return new ArrayList<>(messages);
}
}

// 2. 基于Token限制的内存
@Component
public static class TokenAwareMemory implements Memory {
private final List<ChatMessage> messages;
private final Tokenizer tokenizer;
private final int maxTokens;

public TokenAwareMemory(Tokenizer tokenizer,
@Value("${memory.max.tokens:4096}") int maxTokens) {
this.tokenizer = tokenizer;
this.maxTokens = maxTokens;
this.messages = new ArrayList<>();
}

@Override
public void add(ChatMessage message) {
messages.add(message);
trimToMaxTokens();
}

private void trimToMaxTokens() {
int totalTokens = calculateTotalTokens();

while (totalTokens > maxTokens && !messages.isEmpty()) {
messages.remove(0);
totalTokens = calculateTotalTokens();
}
}

private int calculateTotalTokens() {
return messages.stream()
.mapToInt(msg -> tokenizer.countTokens(msg.getContent()))
.sum();
}
}

// 3. 持久化内存（数据库支持）
@Repository
public static class PersistentMemory implements Memory {
private final JdbcTemplate jdbcTemplate;
private final String sessionId;

@Autowired
public PersistentMemory(JdbcTemplate jdbcTemplate,
@Value("#{request.session.id}") String sessionId) {
this.jdbcTemplate = jdbcTemplate;
this.sessionId = sessionId;
}

@Override
@Transactional
public void add(ChatMessage message) {
String sql = "INSERT INTO chat_memory (session_id, role, content, created_at) " +
"VALUES (?, ?, ?, ?)";
jdbcTemplate.update(sql,
sessionId,
message.getRole(),
message.getContent(),
Instant.now());
}

@Override
public List<ChatMessage> getMessages() {
String sql = "SELECT role, content FROM chat_memory " +
"WHERE session_id = ? ORDER BY created_at ASC";
return jdbcTemplate.query(sql,
(rs, rowNum) -> new ChatMessage(
rs.getString("role"),
rs.getString("content")
),
sessionId);
}
}
}

三、与 LangChain (Python) 的本质区别

3.1 语言特性差异对比

/**
* LangChain4j vs LangChain (Python) 核心差异分析
*/
public class LangChainComparison {

/**
* 差异1：类型系统
*/
public static class TypeSystemComparison {
// Java: 编译时类型检查
public <T extends LanguageModel> T createModel(Class<T> clazz) {
// 编译时确保类型安全
return clazz.cast(createInstance());
}

// Python: 鸭子类型（运行时检查）
// def create_model(model_class):
// # 运行时才能发现类型错误
// return model_class()
}

/**
* 差异2：并发模型
*/
public static class ConcurrencyComparison {
// Java: 丰富的并发工具
public CompletableFuture<String> processConcurrently(List<String> inputs) {
List<CompletableFuture<String>> futures = inputs.stream()
.map(input -> CompletableFuture.supplyAsync(() -> process(input)))
.collect(Collectors.toList());

return CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
.thenApply(v -> futures.stream()
.map(CompletableFuture::join)
.collect(Collectors.joining(", ")));
}

// Python: 基于 asyncio
// async def process_concurrently(inputs):
// tasks = [asyncio.create_task(process(input)) for input in inputs]
// results = await asyncio.gather(*tasks)
// return ", ".join(results)
}

/**
* 差异3：内存管理
*/
public static class MemoryManagementComparison {
// Java: 自动垃圾回收，但需要关注内存泄漏
public class MemoryEfficientChain implements Chain<String, String> {
private final WeakReference<ChatLanguageModel> modelRef;

public MemoryEfficientChain(ChatLanguageModel model) {
this.modelRef = new WeakReference<>(model);
}

@Override
public String execute(String input) {
ChatLanguageModel model = modelRef.get();
if (model == null) {
throw new IllegalStateException("Model has been garbage collected");
}
return model.generate(input);
}
}

// Python: 引用计数 + 垃圾回收
// class MemoryEfficientChain:
// def __init__(self, model):
// self.model = weakref.ref(model)
}

/**
* 差异4：异常处理
*/
public static class ExceptionHandlingComparison {
// Java: 受检异常 + 运行时异常
public String callWithRetry(Supplier<String> operation) throws IOException {
int retries = 3;
while (retries > 0) {
try {
return operation.get();
} catch (RateLimitException e) {
retries—;
Thread.sleep(1000); // 明确的异常处理
} catch (NetworkException e) {
throw new IOException("Network error", e); // 异常包装
}
}
throw new RetryExhaustedException("Failed after retries");
}

// Python: 所有异常都是运行时异常
// def call_with_retry(operation):
// retries = 3
// while retries > 0:
// try:
// return operation()
// except RateLimitException:
// retries -= 1
// time.sleep(1)
// except NetworkException as e:
// raise IOError("Network error") from e
// raise RetryExhaustedException("Failed after retries")
}
}

3.2 架构设计差异详解

/**
* LangChain4j 特有的架构特性
*/
public class LangChain4jSpecificFeatures {

/**
* 特性1：Spring Boot 深度集成
*/
@Configuration
@EnableLangChain4j
public static class SpringBootIntegration {

@Bean
@ConditionalOnProperty(name = "langchain4j.provider", havingValue = "openai")
public ChatLanguageModel openAiChatModel(
@Value("${langchain4j.openai.api-key}") String apiKey,
@Value("${langchain4j.openai.model}") String model) {
return OpenAiChatModel.builder()
.apiKey(apiKey)
.modelName(model)
.temperature(0.7)
.build();
}

@Bean
public ConversationalChain conversationalChain(
ChatLanguageModel model,
@Qualifier("windowMemory") Memory memory) {
return ConversationalChain.builder()
.chatModel(model)
.memory(memory)
.build();
}

@RestController
@RequestMapping("/api/chat")
public static class ChatController {

@Autowired
private ConversationalChain chain;

@PostMapping
public ResponseEntity<ChatResponse> chat(@RequestBody ChatRequest request) {
String response = chain.execute(request.getMessage());
return ResponseEntity.ok(new ChatResponse(response));
}

@GetMapping("/stream")
public SseEmitter streamChat(@RequestParam String message) {
SseEmitter emitter = new SseEmitter();

chain.executeStream(message)
.subscribe(
chunk -> emitter.send(chunk),
emitter::completeWithError,
emitter::complete
);

return emitter;
}
}
}

/**
* 特性2：响应式编程支持
*/
public static class ReactiveSupport {

public Flux<String> streamChainExecution(Chain<String, String> chain,
String input) {
return Flux.create(sink -> {
try {
String result = chain.execute(input);
sink.next(result);
sink.complete();
} catch (Exception e) {
sink.error(e);
}
});
}

@Service
public static class ReactiveChainService {

private final ChatLanguageModel model;
private final VectorStore vectorStore;

public ReactiveChainService(ChatLanguageModel model,
VectorStore vectorStore) {
this.model = model;
this.vectorStore = vectorStore;
}

public Mono<String> ragChain(String question) {
return Mono.fromCallable(() -> embeddingModel.embed(question))
.flatMapMany(embedding -> Flux.fromIterable(
vectorStore.findRelevant(embedding, 5)))
.collectList()
.flatMap(segments -> {
String context = buildContext(segments);
return model.generateAsync(buildPrompt(context, question));
});
}
}
}

/**
* 特性3：企业级特性支持
*/
public static class EnterpriseFeatures {

// 1. 分布式追踪
@Component
@Slf4j
public static class TracingChain implements Chain<String, String> {

private final Chain<String, String> delegate;
private final Tracer tracer;

public TracingChain(Chain<String, String> delegate, Tracer tracer) {
this.delegate = delegate;
this.tracer = tracer;
}

@Override
public String execute(String input) {
Span span = tracer.buildSpan("chain.execute").start();

try (Scope scope = tracer.activateSpan(span)) {
span.setTag("input", input);

String result = delegate.execute(input);

span.setTag("output", result);
span.setTag("success", true);

return result;
} catch (Exception e) {
span.setTag("error", true);
span.log(Map.of("error.message", e.getMessage()));
throw e;
} finally {
span.finish();
}
}
}

// 2. 指标监控
@Component
@RequiredArgsConstructor
public static class MonitoredChain implements Chain<String, String> {

private final Chain<String, String> delegate;
private final MeterRegistry meterRegistry;
private final Timer chainExecutionTimer;

public MonitoredChain(Chain<String, String> delegate,
MeterRegistry meterRegistry) {
this.delegate = delegate;
this.meterRegistry = meterRegistry;
this.chainExecutionTimer = Timer.builder("chain.execution.time")
.register(meterRegistry);
}

@Override
public String execute(String input) {
return chainExecutionTimer.record(() -> {
Counter.builder("chain.execution.count")
.tag("chain", delegate.getClass().getSimpleName())
.register(meterRegistry)
.increment();

try {
return delegate.execute(input);
} catch (Exception e) {
Counter.builder("chain.execution.errors")
.tag("chain", delegate.getClass().getSimpleName())
.register(meterRegistry)
.increment();
throw e;
}
});
}
}

// 3. 安全审计
@Aspect
@Component
public static class SecurityAuditAspect {

@Autowired
private AuditService auditService;

@Around("@annotation(Auditable)")
public Object audit(ProceedingJoinPoint joinPoint) throws Throwable {
String methodName = joinPoint.getSignature().getName();
Object[] args = joinPoint.getArgs();

auditService.log(new AuditEvent(
"CHAIN_EXECUTION",
methodName,
Arrays.toString(args),
Instant.now()
));

return joinPoint.proceed();
}
}
}
}

3.3 性能特性对比

/**
* 性能特性对比分析
*/
public class PerformanceComparison {

/**
* 性能测试框架
*/
@SpringBootTest
@RunWith(SpringRunner.class)
public static class PerformanceBenchmark {

@Autowired
private ConversationalChain chain;

@Test
public void benchmarkChainPerformance() {
// 1. 内存使用对比
long javaMemory = measureMemoryUsage(() -> {
for (int i = 0; i < 1000; i++) {
chain.execute("Test message " + i);
}
});

// 2. 并发性能
List<CompletableFuture<String>> futures = IntStream.range(0, 100)
.mapToObj(i -> CompletableFuture.supplyAsync(() ->
chain.execute("Concurrent test " + i)))
.collect(Collectors.toList());

CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
.join();

// 3. GC 行为分析
analyzeGarbageCollection();
}

private long measureMemoryUsage(Runnable task) {
System.gc();
long before = Runtime.getRuntime().totalMemory() –
Runtime.getRuntime().freeMemory();

task.run();

System.gc();
long after = Runtime.getRuntime().totalMemory() –
Runtime.getRuntime().freeMemory();

return after – before;
}

private void analyzeGarbageCollection() {
// Java 提供详细的 GC 日志和分析工具
// -XX:+PrintGCDetails
// -XX:+PrintGCDateStamps
// -Xloggc:gc.log
}
}

/**
* JVM 优化配置示例
*/
public static class JvmOptimization {
// JVM 参数优化
String[] jvmArgs = {
"-Xmx4g", // 最大堆内存
"-Xms4g", // 初始堆内存
"-XX:MaxMetaspaceSize=512m",
"-XX:+UseG1GC", // G1垃圾收集器
"-XX:MaxGCPauseMillis=200",
"-XX:ParallelGCThreads=4",
"-XX:ConcGCThreads=2",
"-XX:+UseStringDeduplication",
"-XX:+HeapDumpOnOutOfMemoryError",
"-XX:HeapDumpPath=./heapdump.hprof"
};

// LangChain4j 特有的性能优化
@Configuration
public static class PerformanceConfig {

@Bean
@Profile("production")
public ChatLanguageModel optimizedChatModel() {
return OpenAiChatModel.builder()
.apiKey(System.getenv("OPENAI_API_KEY"))
.modelName("gpt-3.5-turbo")
.temperature(0.7)
.timeout(Duration.ofSeconds(30))
.maxRetries(3)
.logRequests(true)
.logResponses(false)
.withPersistingCache() // 缓存支持
.withRateLimiter(100, Duration.ofMinutes(1)) // 限流
.build();
}

@Bean
public Memory highPerformanceMemory() {
return new ConcurrentMemory(1000); // 并发安全的内存实现
}

@Bean
public ExecutorService chainExecutorService() {
return new ThreadPoolExecutor(
10, // 核心线程数
50, // 最大线程数
60L, TimeUnit.SECONDS,
new LinkedBlockingQueue<>(1000),
new ThreadPoolExecutor.CallerRunsPolicy()
);
}
}
}
}

四、使用场景对比

4.1 适合 LangChain4j 的场景

/**
* LangChain4j 优势场景示例
*/
public class LangChain4jAdvantageScenarios {

/**
* 场景1：企业级微服务
*/
@SpringBootApplication
@EnableDiscoveryClient
@EnableCircuitBreaker
public class EnterpriseAiServiceApplication {

public static void main(String[] args) {
SpringApplication.run(EnterpriseAiServiceApplication.class, args);
}

@Bean
@LoadBalanced
public RestTemplate restTemplate() {
return new RestTemplate();
}

@Service
@Slf4j
public static class CustomerServiceAiAgent {

@Autowired
private ConversationalChain chain;

@Autowired
private CustomerRepository customerRepository;

@Autowired
private OrderService orderService;

@HystrixCommand(fallbackMethod = "fallbackResponse")
public String handleCustomerQuery(Long customerId, String query) {
// 1. 获取客户信息
Customer customer = customerRepository.findById(customerId)
.orElseThrow();

// 2. 获取订单历史
List<Order> orders = orderService.getRecentOrders(customerId);

// 3. 构建上下文
String context = buildCustomerContext(customer, orders);

// 4. 执行链
return chain.execute(context + "\\n\\nCustomer Query: " + query);
}

private String fallbackResponse(Long customerId, String query) {
return "I'm currently unable to process your request. Please try again later.";
}
}
}

/**
* 场景2：高并发实时处理
*/
@Service
public class RealTimeProcessingService {

private final ChatLanguageModel model;
private final ExecutorService executorService;
private final RateLimiter rateLimiter;

public RealTimeProcessingService() {
this.model = createOptimizedModel();
this.executorService = Executors.newFixedThreadPool(50);
this.rateLimiter = RateLimiter.create(100); // 100 requests per second
}

public List<CompletableFuture<String>> batchProcess(
List<String> inputs, int timeoutSeconds) {

return inputs.stream()
.map(input -> CompletableFuture.supplyAsync(() -> {
rateLimiter.acquire(); // 限流控制
return processWithTimeout(input, timeoutSeconds);
}, executorService))
.collect(Collectors.toList());
}

private String processWithTimeout(String input, int timeoutSeconds) {
try {
return model.generateAsync(input)
.get(timeoutSeconds, TimeUnit.SECONDS);
} catch (TimeoutException e) {
return "Processing timeout";
} catch (Exception e) {
return "Error processing input";
}
}
}

/**
* 场景3：事务性AI操作
*/
@Service
@Transactional
@Slf4j
public class TransactionalAiService {

@Autowired
private ChatLanguageModel model;

@Autowired
private DocumentRepository documentRepository;

@Autowired
private AuditLogRepository auditLogRepository;

public Document processDocument(Long documentId, String instruction) {
// 1. 获取文档
Document document = documentRepository.findById(documentId)
.orElseThrow();

// 2. AI处理
String processedContent = model.generate(
"Process this document: " + document.getContent() +
"\\nInstruction: " + instruction
);

// 3. 更新文档
document.setContent(processedContent);
document.setProcessedAt(Instant.now());

// 4. 记录审计日志
AuditLog log = new AuditLog();
log.setAction("AI_PROCESSING");
log.setDocumentId(documentId);
log.setDetails("Processed with instruction: " + instruction);
auditLogRepository.save(log);

// 所有操作在同一个事务中
return documentRepository.save(document);
}
}
}

4.2 适合 LangChain (Python) 的场景

"""
LangChain (Python) 优势场景示例
"""
class PythonAdvantageScenarios:

def scenario_1_rapid_prototyping(self):
"""
场景1：快速原型开发
Python的动态特性适合快速实验
"""
# 动态创建链
chain = LLMChain(
llm=OpenAI(temperature=0.7),
prompt=PromptTemplate(
input_variables=["topic"],
template="Tell me about {topic}"
)
)

# 动态修改
chain.llm.temperature = 0.9 # 运行时修改参数
chain.prompt.template = "Explain {topic} in detail" # 运行时修改模板

return chain

def scenario_2_research_experimentation(self):
"""
场景2：研究和实验
Python丰富的科学计算库支持
"""
import numpy as np
import pandas as pd
from langchain.evaluation import load_evaluator

# 实验不同参数
results = []
for temperature in np.arange(0.1, 1.0, 0.1):
for model in ["gpt-3.5-turbo", "gpt-4"]:
chain = self.create_chain(model, temperature)
score = self.evaluate_chain(chain)
results.append({
"model": model,
"temperature": temperature,
"score": score
})

# 分析结果
df = pd.DataFrame(results)
return df.groupby("model").mean()

def scenario_3_data_science_integration(self):
"""
场景3：数据科学集成
"""
from sklearn.feature_extraction.text import TfidfVectorizer
from langchain.chains import TransformChain

# 自定义转换函数
def tfidf_transform(inputs):
texts = inputs["texts"]
vectorizer = TfidfVectorizer()
vectors = vectorizer.fit_transform(texts)
return {"vectors": vectors}

# 创建自定义链
tfidf_chain = TransformChain(
input_variables=["texts"],
output_variables=["vectors"],
transform=tfidf_transform
)

return tfidf_chain

五、总结对比表格

核心区别总结：

选择建议：

• 选择 LangChain4j：需要构建高并发、高可用的企业级AI应用
• 选择 LangChain (Python)：进行AI研究、快速原型开发或数据科学项目