高级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 核心设计原则实现示例 */publicclassLangChain4jDesignPrinciples{// 原则1：类型安全（Type Safety）publicstaticclassTypeSafetyExample{// Java 强类型系统确保编译时类型检查public<TextendsLanguageModel>TcreateModel(Class<T> modelClass){// 避免Python中的运行时类型错误return modelClass.getDeclaredConstructor().newInstance();}// 泛型确保链式调用类型安全public<I,O>Chain<I,O>createChain(Transformer<I,O> transformer){returnChain.of(transformer);}}// 原则2：不可变性（Immutability）@ImmutablepublicstaticclassChatMessage{privatefinalString role;privatefinalString content;privatefinalInstant timestamp;publicChatMessage(String role,String content){this.role = role;this.content = content;this.timestamp =Instant.now();}// 没有setter，只有getterpublicStringgetRole(){return role;}publicStringgetContent(){return content;}// 返回新实例而不是修改现有实例publicChatMessagewithContent(String newContent){returnnewChatMessage(this.role, newContent);}}// 原则3：声明式配置（Declarative Configuration）@ConfigurationProperties(prefix ="langchain4j")publicstaticclassLangChain4jConfig{privateString openAiApiKey;privateString modelName ="gpt-3.5-turbo";privatedouble temperature =0.7;privateDuration timeout =Duration.ofSeconds(60);// 自动绑定配置// @Configuration + @Bean 提供类型安全的依赖注入}// 原则4：响应式编程支持（Reactive Programming）publicstaticclassReactiveExample{publicFlux<ChatMessage>streamChatCompletion(ChatLanguageModel model,String userMessage){return model.generate(userMessage).map(response ->newChatMessage("assistant", response)).delayElements(Duration.ofMillis(100));}}}

二、LangChain4j 核心组件详细设计

2.1 LLM 抽象层设计

/** * LLM 核心抽象层设计 */publicinterfaceLanguageModel{// 同步生成Stringgenerate(String prompt);// 异步生成CompletableFuture<String>generateAsync(String prompt);// 流式生成Stream<String>generateStream(String prompt);// 带参数的生成Stringgenerate(String prompt,GenerationParameters parameters);}/** * 聊天模型抽象 */publicinterfaceChatLanguageModelextendsLanguageModel{// 消息历史管理List<ChatMessage>getHistory();// 带上下文的聊天Stringchat(List<ChatMessage> messages);// 工具调用支持ChatResponsechatWithTools(List<ChatMessage> messages,List<ToolSpecification> tools);}/** * 嵌入式模型抽象 */publicinterfaceEmbeddingModel{// 单文本嵌入Embeddingembed(String text);// 批量嵌入List<Embedding>embedAll(List<String> texts);// 维度信息intdimension();}/** * 具体实现示例 - OpenAI */@ServicepublicclassOpenAiChatModelimplementsChatLanguageModel{privatefinalOpenAiClient client;privatefinalGson gson;privatefinalRateLimiter rateLimiter;// 构造函数注入 - 依赖倒置原则@AutowiredpublicOpenAiChatModel(OpenAiClient client,@Qualifier("langchainGson")Gson gson,RateLimiter rateLimiter){this.client = client;this.gson = gson;this.rateLimiter = rateLimiter;}@OverridepublicStringgenerate(String prompt){// 使用组合模式而不是继承returnexecuteWithRetry(()->{OpenAiRequest request =buildRequest(prompt);OpenAiResponse response = client.chat(request);returnextractContent(response);});}@OverridepublicStream<String>generateStream(String prompt){returnStream.generate(()->{// 流式响应处理returnprocessStreamResponse();});}privateStringexecuteWithRetry(Supplier<String> operation){// 重试机制returnRetryUtils.retry(operation,3,Duration.ofSeconds(2));}}

2.2 链（Chain）设计模式

/** * 链的抽象定义 */publicinterfaceChain<I,O>{Oexecute(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;}}/** * 具体链实现 */@ComponentpublicclassConversationalChainimplementsChain<String,String>{privatefinalChatLanguageModel model;privatefinalMemory memory;privatefinalList<Transformer<String,String>> preprocessors;privatefinalList<Transformer<String,String>> postprocessors;// 建造者模式publicstaticclassBuilder{privateChatLanguageModel model;privateMemory memory =newSimpleMemory();privateList<Transformer<String,String>> preprocessors =newArrayList<>();privateList<Transformer<String,String>> postprocessors =newArrayList<>();publicBuilderwithModel(ChatLanguageModel model){this.model = model;returnthis;}publicBuilderwithMemory(Memory memory){this.memory = memory;returnthis;}publicBuilderaddPreprocessor(Transformer<String,String> preprocessor){this.preprocessors.add(preprocessor);returnthis;}publicConversationalChainbuild(){returnnewConversationalChain(this);}}privateConversationalChain(Builder builder){this.model = builder.model;this.memory = builder.memory;this.preprocessors = builder.preprocessors;this.postprocessors = builder.postprocessors;}@OverridepublicStringexecute(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 =newArrayList<>(history); messages.add(newUserMessage(processedInput));// 调用模型String response = model.chat(messages);// 后处理String processedResponse = postprocessors.stream().reduce(Function.identity(),(f1, f2)-> f1.andThen(f2),Function::identity).apply(response);// 保存到记忆 memory.add(newUserMessage(processedInput)); memory.add(newAssistantMessage(processedResponse));return processedResponse;}}/** * 复杂链组合示例 */@ServicepublicclassDocumentQaChainimplementsChain<String,String>{privatefinalEmbeddingModel embeddingModel;privatefinalVectorStore vectorStore;privatefinalChatLanguageModel chatModel;privatefinalPromptTemplate promptTemplate;publicDocumentQaChain(EmbeddingModel embeddingModel,VectorStore vectorStore,ChatLanguageModel chatModel){this.embeddingModel = embeddingModel;this.vectorStore = vectorStore;this.chatModel = chatModel;this.promptTemplate =newPromptTemplate("基于以下上下文回答问题：\n\n上下文：{context}\n\n问题：{question}\n\n答案：");}@OverridepublicStringexecute(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）系统设计

/** * 内存抽象接口 */publicinterfaceMemory{voidadd(ChatMessage message);List<ChatMessage>getMessages();List<ChatMessage>getMessages(int limit);voidclear();defaultbooleanisEmpty(){returngetMessages().isEmpty();}}/** * 不同类型的内存实现 */publicclassMemorySystemDesign{// 1. 基于窗口的内存@Component@Scope("session")// 支持会话作用域publicstaticclassWindowMemoryimplementsMemory{privatefinalDeque<ChatMessage> messages;privatefinalint windowSize;publicWindowMemory(@Value("${memory.window.size:10}")int windowSize){this.windowSize = windowSize;this.messages =newArrayDeque<>(windowSize);}@Overridepublicsynchronizedvoidadd(ChatMessage message){if(messages.size()>= windowSize){ messages.removeFirst();} messages.addLast(message);}@OverridepublicList<ChatMessage>getMessages(){returnnewArrayList<>(messages);}}// 2. 基于Token限制的内存@ComponentpublicstaticclassTokenAwareMemoryimplementsMemory{privatefinalList<ChatMessage> messages;privatefinalTokenizer tokenizer;privatefinalint maxTokens;publicTokenAwareMemory(Tokenizer tokenizer,@Value("${memory.max.tokens:4096}")int maxTokens){this.tokenizer = tokenizer;this.maxTokens = maxTokens;this.messages =newArrayList<>();}@Overridepublicvoidadd(ChatMessage message){ messages.add(message);trimToMaxTokens();}privatevoidtrimToMaxTokens(){int totalTokens =calculateTotalTokens();while(totalTokens > maxTokens &&!messages.isEmpty()){ messages.remove(0); totalTokens =calculateTotalTokens();}}privateintcalculateTotalTokens(){return messages.stream().mapToInt(msg -> tokenizer.countTokens(msg.getContent())).sum();}}// 3. 持久化内存（数据库支持）@RepositorypublicstaticclassPersistentMemoryimplementsMemory{privatefinalJdbcTemplate jdbcTemplate;privatefinalString sessionId;@AutowiredpublicPersistentMemory(JdbcTemplate jdbcTemplate,@Value("#{request.session.id}")String sessionId){this.jdbcTemplate = jdbcTemplate;this.sessionId = sessionId;}@Override@Transactionalpublicvoidadd(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());}@OverridepublicList<ChatMessage>getMessages(){String sql ="SELECT role, content FROM chat_memory "+"WHERE session_id = ? ORDER BY created_at ASC";return jdbcTemplate.query(sql,(rs, rowNum)->newChatMessage( rs.getString("role"), rs.getString("content")), sessionId);}}}

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

3.1 语言特性差异对比

/** * LangChain4j vs LangChain (Python) 核心差异分析 */publicclassLangChainComparison{/** * 差异1：类型系统 */publicstaticclassTypeSystemComparison{// Java: 编译时类型检查public<TextendsLanguageModel>TcreateModel(Class<T> clazz){// 编译时确保类型安全return clazz.cast(createInstance());}// Python: 鸭子类型（运行时检查）// def create_model(model_class):// # 运行时才能发现类型错误// return model_class()}/** * 差异2：并发模型 */publicstaticclassConcurrencyComparison{// Java: 丰富的并发工具publicCompletableFuture<String>processConcurrently(List<String> inputs){List<CompletableFuture<String>> futures = inputs.stream().map(input ->CompletableFuture.supplyAsync(()->process(input))).collect(Collectors.toList());returnCompletableFuture.allOf(futures.toArray(newCompletableFuture[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：内存管理 */publicstaticclassMemoryManagementComparison{// Java: 自动垃圾回收，但需要关注内存泄漏publicclassMemoryEfficientChainimplementsChain<String,String>{privatefinalWeakReference<ChatLanguageModel> modelRef;publicMemoryEfficientChain(ChatLanguageModel model){this.modelRef =newWeakReference<>(model);}@OverridepublicStringexecute(String input){ChatLanguageModel model = modelRef.get();if(model ==null){thrownewIllegalStateException("Model has been garbage collected");}return model.generate(input);}}// Python: 引用计数 + 垃圾回收// class MemoryEfficientChain:// def __init__(self, model):// self.model = weakref.ref(model)}/** * 差异4：异常处理 */publicstaticclassExceptionHandlingComparison{// Java: 受检异常 + 运行时异常publicStringcallWithRetry(Supplier<String> operation)throwsIOException{int retries =3;while(retries >0){try{return operation.get();}catch(RateLimitException e){ retries--;Thread.sleep(1000);// 明确的异常处理}catch(NetworkException e){thrownewIOException("Network error", e);// 异常包装}}thrownewRetryExhaustedException("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 特有的架构特性 */publicclassLangChain4jSpecificFeatures{/** * 特性1：Spring Boot 深度集成 */@Configuration@EnableLangChain4jpublicstaticclassSpringBootIntegration{@Bean@ConditionalOnProperty(name ="langchain4j.provider", havingValue ="openai")publicChatLanguageModelopenAiChatModel(@Value("${langchain4j.openai.api-key}")String apiKey,@Value("${langchain4j.openai.model}")String model){returnOpenAiChatModel.builder().apiKey(apiKey).modelName(model).temperature(0.7).build();}@BeanpublicConversationalChainconversationalChain(ChatLanguageModel model,@Qualifier("windowMemory")Memory memory){returnConversationalChain.builder().chatModel(model).memory(memory).build();}@RestController@RequestMapping("/api/chat")publicstaticclassChatController{@AutowiredprivateConversationalChain chain;@PostMappingpublicResponseEntity<ChatResponse>chat(@RequestBodyChatRequest request){String response = chain.execute(request.getMessage());returnResponseEntity.ok(newChatResponse(response));}@GetMapping("/stream")publicSseEmitterstreamChat(@RequestParamString message){SseEmitter emitter =newSseEmitter(); chain.executeStream(message).subscribe( chunk -> emitter.send(chunk), emitter::completeWithError, emitter::complete);return emitter;}}}/** * 特性2：响应式编程支持 */publicstaticclassReactiveSupport{publicFlux<String>streamChainExecution(Chain<String,String> chain,String input){returnFlux.create(sink ->{try{String result = chain.execute(input); sink.next(result); sink.complete();}catch(Exception e){ sink.error(e);}});}@ServicepublicstaticclassReactiveChainService{privatefinalChatLanguageModel model;privatefinalVectorStore vectorStore;publicReactiveChainService(ChatLanguageModel model,VectorStore vectorStore){this.model = model;this.vectorStore = vectorStore;}publicMono<String>ragChain(String question){returnMono.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：企业级特性支持 */publicstaticclassEnterpriseFeatures{// 1. 分布式追踪@Component@Slf4jpublicstaticclassTracingChainimplementsChain<String,String>{privatefinalChain<String,String> delegate;privatefinalTracer tracer;publicTracingChain(Chain<String,String> delegate,Tracer tracer){this.delegate = delegate;this.tracer = tracer;}@OverridepublicStringexecute(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@RequiredArgsConstructorpublicstaticclassMonitoredChainimplementsChain<String,String>{privatefinalChain<String,String> delegate;privatefinalMeterRegistry meterRegistry;privatefinalTimer chainExecutionTimer;publicMonitoredChain(Chain<String,String> delegate,MeterRegistry meterRegistry){this.delegate = delegate;this.meterRegistry = meterRegistry;this.chainExecutionTimer =Timer.builder("chain.execution.time").register(meterRegistry);}@OverridepublicStringexecute(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@ComponentpublicstaticclassSecurityAuditAspect{@AutowiredprivateAuditService auditService;@Around("@annotation(Auditable)")publicObjectaudit(ProceedingJoinPoint joinPoint)throwsThrowable{String methodName = joinPoint.getSignature().getName();Object[] args = joinPoint.getArgs(); auditService.log(newAuditEvent("CHAIN_EXECUTION", methodName,Arrays.toString(args),Instant.now()));return joinPoint.proceed();}}}}

3.3 性能特性对比

/** * 性能特性对比分析 */publicclassPerformanceComparison{/** * 性能测试框架 */@SpringBootTest@RunWith(SpringRunner.class)publicstaticclassPerformanceBenchmark{@AutowiredprivateConversationalChain chain;@TestpublicvoidbenchmarkChainPerformance(){// 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(newCompletableFuture[0])).join();// 3. GC 行为分析analyzeGarbageCollection();}privatelongmeasureMemoryUsage(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;}privatevoidanalyzeGarbageCollection(){// Java 提供详细的 GC 日志和分析工具// -XX:+PrintGCDetails// -XX:+PrintGCDateStamps// -Xloggc:gc.log}}/** * JVM 优化配置示例 */publicstaticclassJvmOptimization{// 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 特有的性能优化@ConfigurationpublicstaticclassPerformanceConfig{@Bean@Profile("production")publicChatLanguageModeloptimizedChatModel(){returnOpenAiChatModel.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();}@BeanpublicMemoryhighPerformanceMemory(){returnnewConcurrentMemory(1000);// 并发安全的内存实现}@BeanpublicExecutorServicechainExecutorService(){returnnewThreadPoolExecutor(10,// 核心线程数50,// 最大线程数60L,TimeUnit.SECONDS,newLinkedBlockingQueue<>(1000),newThreadPoolExecutor.CallerRunsPolicy());}}}}

四、使用场景对比

4.1 适合 LangChain4j 的场景

/** * LangChain4j 优势场景示例 */publicclassLangChain4jAdvantageScenarios{/** * 场景1：企业级微服务 */@SpringBootApplication@EnableDiscoveryClient@EnableCircuitBreakerpublicclassEnterpriseAiServiceApplication{publicstaticvoidmain(String[] args){SpringApplication.run(EnterpriseAiServiceApplication.class, args);}@Bean@LoadBalancedpublicRestTemplaterestTemplate(){returnnewRestTemplate();}@Service@Slf4jpublicstaticclassCustomerServiceAiAgent{@AutowiredprivateConversationalChain chain;@AutowiredprivateCustomerRepository customerRepository;@AutowiredprivateOrderService orderService;@HystrixCommand(fallbackMethod ="fallbackResponse")publicStringhandleCustomerQuery(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);}privateStringfallbackResponse(Long customerId,String query){return"I'm currently unable to process your request. Please try again later.";}}}/** * 场景2：高并发实时处理 */@ServicepublicclassRealTimeProcessingService{privatefinalChatLanguageModel model;privatefinalExecutorService executorService;privatefinalRateLimiter rateLimiter;publicRealTimeProcessingService(){this.model =createOptimizedModel();this.executorService =Executors.newFixedThreadPool(50);this.rateLimiter =RateLimiter.create(100);// 100 requests per second}publicList<CompletableFuture<String>>batchProcess(List<String> inputs,int timeoutSeconds){return inputs.stream().map(input ->CompletableFuture.supplyAsync(()->{ rateLimiter.acquire();// 限流控制returnprocessWithTimeout(input, timeoutSeconds);}, executorService)).collect(Collectors.toList());}privateStringprocessWithTimeout(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@Slf4jpublicclassTransactionalAiService{@AutowiredprivateChatLanguageModel model;@AutowiredprivateDocumentRepository documentRepository;@AutowiredprivateAuditLogRepository auditLogRepository;publicDocumentprocessDocument(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 =newAuditLog(); 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) 优势场景示例 """classPythonAdvantageScenarios:defscenario_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 defscenario_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()defscenario_3_data_science_integration(self):""" 场景3：数据科学集成 """from sklearn.feature_extraction.text import TfidfVectorizer from langchain.chains import TransformChain # 自定义转换函数deftfidf_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 

五、总结对比表格

核心区别总结：

1. 哲学差异：
   • LangChain4j：工程严谨性优先，强调类型安全、性能和可维护性
   • LangChain (Python)：开发效率优先，强调灵活性和快速迭代
2. 架构差异：
   • LangChain4j：面向企业架构，深度集成Spring生态
   • LangChain (Python)：面向研究和原型，强调易用性和扩展性
3. 运行时差异：
   • LangChain4j：运行在JVM上，享受JIT编译和成熟的GC
   • LangChain (Python)：运行在CPython解释器上，受GIL限制

选择建议：

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