当前位置:   article > 正文

LangChain4j实战_langchain4j 实战

langchain4j 实战

基础

LangChain4j模型适配:

Provider

Native Image

Sync Completion

Streaming Completion

Embedding

Image Generation

Scoring

Function Calling

OpenAI

Azure OpenAI

Hugging Face

Amazon Bedrock

Google Vertex AI Gemini

Google Vertex AI

Mistral AI

DashScope

LocalAI

Ollama

Cohere

Qianfan

ChatGLM

Nomic

Anthropic

Zhipu AI

Langchain实战应用场景:

https://github.com/lyhue1991/eat_chatgpt/blob/main/3_langchain_9_usecases.ipynb

官方文档:

LangChain4j | LangChain4j

官方LangChain4j使用示例

https://github.com/langchain4j/langchain4j-examples.git

基本使用示例是比较完整

官方SpringBoot整合示例

Spring Boot Integration | LangChain4j

SpringBoot实战使用示例

自己写的demo, 使用LangChain4j为内部系统生成有意义的测试数据

https://github.com/kvenLin/spring-langchain-demo

LangChain4j的实战用例讲解

核心功能

LangChain4j已经将很多和大模型进行复杂的操作进行了简化,对于后端程序员只需要调用指定的API即可

个人觉得还是需要提前理解LangChain的基础架构, 了解每个模块的作用, 使用起来才会更容易

LangChain4j主要的核心的几个功能就是:

  • Chat and Language Models: 切换大模型
  • Chat Memory: 对系统内聊天指定聊天memoryId进行区分, 可以根据memoryId来持续对话内容
  • Model Parameters: 根据您选择的模型型号和提供程序,可以调整许多参数
  • Response Streaming: 响应流式处理, LLM提供程序提供了一种逐个令牌流式传输响应的方法,而不是等待生成整个文本
  • AI Services: 比较高级的核心功能, 通过代理的形式帮我们实现特定的Service层的服务, 只需要关注业务, 不需要关注底层实现
  • Tools (Function Calling): 除了生成文本外,还可以触发操作。在tools层可以根据触发条件调用不同的函数, 也是比较核心的模块, 对于AI-Agent的实现是必须的.
  • RAG (Retrieval-Augmented Generation): 根据特定的 文档+向量化 数据, 来扩展模型的知识库, 提高搜索的有效性
  • Structured Data Extraction: 这里官方文档还没有完善, 但是examples中可以找打使用示例, 主要的作用是根据文本数据抽取我们需要的信息, 并封装成对Java有意义的自定义的结构化对象.
  • Classification: 官方文档待完善...
  • Embedding (Vector) Stores: 向量数据的存储功能, 提供了很多示例, 可以使用ES、Redis
  • Chains: 官方文档待完善...
  • Image Models: 官方文档待完善...

使用教程

AI Service

工作原理

官方解释: 将接口与低级组件一起提供 Class , AiServices 并 AiServices 创建实现此接口的代理对象。目前,它使用反射,但我们也在考虑替代方案。此代理对象处理输入和输出的所有转换。在本例中,输入是单个 String ,但我们使用ChatLanguageModel 作为 ChatMessage 输入。因此, AiService 会自动将其转换为 UserMessage 并调用 ChatLanguageModel .由于 chat 该方法的输出类型是 String ,在返回 AiMessage 后 ChatLanguageModel ,它会在从 chat 方法返回之前转换为 String。

实际上就是代理形式帮我们实现了定义的业务接口

POJO抽取
  1. public class POJO_Extracting_AI_Service_Example {
  2. static ChatLanguageModel model = OpenAiChatModel.builder()
  3. .baseUrl(ApiKeys.BASE_URL)
  4. .apiKey(ApiKeys.OPENAI_API_KEY)
  5. .logRequests(true)
  6. .logResponses(true)
  7. .timeout(ofSeconds(60))
  8. .build();
  9. static class Person {
  10. private String firstName;
  11. private String lastName;
  12. private LocalDate birthDate;
  13. @Override
  14. public String toString() {
  15. return "Person {" +
  16. " firstName = \"" + firstName + "\"" +
  17. ", lastName = \"" + lastName + "\"" +
  18. ", birthDate = " + birthDate +
  19. " }";
  20. }
  21. }
  22. interface PersonExtractor {
  23. @UserMessage("Extract information about a person from {{it}}")
  24. Person extractPersonFrom(String text);
  25. }
  26. public static void main(String[] args) {
  27. PersonExtractor extractor = AiServices.create(PersonExtractor.class, model);
  28. String text = "In 1968, amidst the fading echoes of Independence Day, "
  29. + "a child named John arrived under the calm evening sky. "
  30. + "This newborn, bearing the surname Doe, marked the start of a new journey.";
  31. Person person = extractor.extractPersonFrom(text);
  32. System.out.println(person); // Person { firstName = "John", lastName = "Doe", birthDate = 1968-07-04 }
  33. }
  34. }
  • 自定义的业务需要的对象: Person对象
  • 定义业务接口: PersonExtractor
  • @UserMessage标注当前接口方法使用来做什么的
  • text 会自动预处理, 在 @UserMessage 中进行替换{{it}}

最后得到的就是Service自动从文本中抽取数据并自动构建的Person对象

应用场景:

  • 可以对用户模糊描述提取有用的信息, 进行精确的业务处理
  • 对文档提取特定的数据进行业务处理
@SystemMessage的使用

限定AI角色区分service不同函数实现功能

  1. public class AI_Service_with_System_and_User_Messages_Example {
  2. static ChatLanguageModel model = OpenAiChatModel.builder()
  3. .baseUrl(ApiKeys.BASE_URL)
  4. .apiKey(ApiKeys.OPENAI_API_KEY)
  5. .logRequests(true)
  6. .logResponses(true)
  7. .timeout(ofSeconds(60))
  8. .build();
  9. interface TextUtils {
  10. @SystemMessage("You are a professional translator into {{language}}")
  11. @UserMessage("Translate the following text: {{text}}")
  12. String translate(@V("text") String text, @V("language") String language);
  13. @SystemMessage("Summarize every message from user in {{n}} bullet points. Provide only bullet points.")
  14. List<String> summarize(@UserMessage String text, @V("n") int n);
  15. }
  16. public static void main(String[] args) {
  17. TextUtils utils = AiServices.create(TextUtils.class, model);
  18. String translation = utils.translate("Hello, how are you?", "italian");
  19. System.out.println(translation); // Ciao, come stai?
  20. String text = "AI, or artificial intelligence, is a branch of computer science that aims to create "
  21. + "machines that mimic human intelligence. This can range from simple tasks such as recognizing "
  22. + "patterns or speech to more complex tasks like making decisions or predictions.";
  23. List<String> bulletPoints = utils.summarize(text, 3);
  24. bulletPoints.forEach(System.out::println);
  25. // [
  26. // "- AI is a branch of computer science",
  27. // "- It aims to create machines that mimic human intelligence",
  28. // "- It can perform simple or complex tasks"
  29. // ]
  30. }
  31. }
文本分析情感

根据文本内容分析情感色彩, 积极、中立、消极

  1. public class Sentiment_Extracting_AI_Service_Example {
  2. static ChatLanguageModel model = OpenAiChatModel.builder()
  3. .baseUrl(ApiKeys.BASE_URL)
  4. .apiKey(ApiKeys.OPENAI_API_KEY)
  5. .logRequests(true)
  6. .logResponses(true)
  7. .timeout(ofSeconds(60))
  8. .build();
  9. enum Sentiment {
  10. POSITIVE, NEUTRAL, NEGATIVE;
  11. }
  12. interface SentimentAnalyzer {
  13. @UserMessage("Analyze sentiment of {{it}}")
  14. Sentiment analyzeSentimentOf(String text);
  15. @UserMessage("Does {{it}} have a positive sentiment?")
  16. boolean isPositive(String text);
  17. }
  18. public static void main(String[] args) {
  19. SentimentAnalyzer sentimentAnalyzer = AiServices.create(SentimentAnalyzer.class, model);
  20. Sentiment sentiment = sentimentAnalyzer.analyzeSentimentOf("It is good!");
  21. System.out.println(sentiment); // POSITIVE
  22. boolean positive = sentimentAnalyzer.isPositive("It is bad!");
  23. System.out.println(positive); // false
  24. }
  25. }
文本数据类型转换
  1. public class Number_Extracting_AI_Service_Example {
  2. static ChatLanguageModel model = OpenAiChatModel.builder()
  3. .baseUrl(ApiKeys.BASE_URL)
  4. .apiKey(ApiKeys.OPENAI_API_KEY)
  5. .logRequests(true)
  6. .logResponses(true)
  7. .timeout(ofSeconds(60))
  8. .build();
  9. interface NumberExtractor {
  10. @UserMessage("Extract number from {{it}}")
  11. int extractInt(String text);
  12. @UserMessage("Extract number from {{it}}")
  13. long extractLong(String text);
  14. @UserMessage("Extract number from {{it}}")
  15. BigInteger extractBigInteger(String text);
  16. @UserMessage("Extract number from {{it}}")
  17. float extractFloat(String text);
  18. @UserMessage("Extract number from {{it}}")
  19. double extractDouble(String text);
  20. @UserMessage("Extract number from {{it}}")
  21. BigDecimal extractBigDecimal(String text);
  22. }
  23. public static void main(String[] args) {
  24. NumberExtractor extractor = AiServices.create(NumberExtractor.class, model);
  25. String text = "After countless millennia of computation, the supercomputer Deep Thought finally announced "
  26. + "that the answer to the ultimate question of life, the universe, and everything was forty two.";
  27. int intNumber = extractor.extractInt(text);
  28. System.out.println(intNumber); // 42
  29. long longNumber = extractor.extractLong(text);
  30. System.out.println(longNumber); // 42
  31. BigInteger bigIntegerNumber = extractor.extractBigInteger(text);
  32. System.out.println(bigIntegerNumber); // 42
  33. float floatNumber = extractor.extractFloat(text);
  34. System.out.println(floatNumber); // 42.0
  35. double doubleNumber = extractor.extractDouble(text);
  36. System.out.println(doubleNumber); // 42.0
  37. BigDecimal bigDecimalNumber = extractor.extractBigDecimal(text);
  38. System.out.println(bigDecimalNumber); // 42.0
  39. }
  40. }

  1. public class Date_and_Time_Extracting_AI_Service_Example {
  2. static ChatLanguageModel model = OpenAiChatModel.builder()
  3. .baseUrl(ApiKeys.BASE_URL)
  4. .apiKey(ApiKeys.OPENAI_API_KEY)
  5. .logRequests(true)
  6. .logResponses(true)
  7. .timeout(ofSeconds(60))
  8. .build();
  9. interface DateTimeExtractor {
  10. @UserMessage("Extract date from {{it}}")
  11. LocalDate extractDateFrom(String text);
  12. @UserMessage("Extract time from {{it}}")
  13. LocalTime extractTimeFrom(String text);
  14. @UserMessage("Extract date and time from {{it}}")
  15. LocalDateTime extractDateTimeFrom(String text);
  16. }
  17. public static void main(String[] args) {
  18. DateTimeExtractor extractor = AiServices.create(DateTimeExtractor.class, model);
  19. String text = "The tranquility pervaded the evening of 1968, just fifteen minutes shy of midnight,"
  20. + " following the celebrations of Independence Day.";
  21. LocalDate date = extractor.extractDateFrom(text);
  22. System.out.println(date); // 1968-07-04
  23. LocalTime time = extractor.extractTimeFrom(text);
  24. System.out.println(time); // 23:45
  25. LocalDateTime dateTime = extractor.extractDateTimeFrom(text);
  26. System.out.println(dateTime); // 1968-07-04T23:45
  27. }
  28. }
区分对话和记忆
  1. public class ServiceWithMemoryExample {
  2. static ChatLanguageModel model = OpenAiChatModel.builder()
  3. .baseUrl(ApiKeys.BASE_URL)
  4. .apiKey(ApiKeys.OPENAI_API_KEY)
  5. .logRequests(true)
  6. .logResponses(true)
  7. .timeout(ofSeconds(60))
  8. .build();
  9. interface Assistant {
  10. String chat(@MemoryId int memoryId, @UserMessage String userMessage);
  11. }
  12. public static void main(String[] args) {
  13. Assistant assistant = AiServices.builder(Assistant.class)
  14. .chatLanguageModel(model)
  15. .chatMemoryProvider(memoryId -> MessageWindowChatMemory.withMaxMessages(10))
  16. .build();
  17. System.out.println(assistant.chat(1, "Hello, my name is Klaus"));
  18. // Hi Klaus! How can I assist you today?
  19. System.out.println(assistant.chat(2, "Hello, my name is Francine"));
  20. // Hello Francine! How can I assist you today?
  21. System.out.println(assistant.chat(1, "What is my name?"));
  22. // Your name is Klaus.
  23. System.out.println(assistant.chat(2, "What is my name?"));
  24. // Your name is Francine.
  25. }
  26. }

AI Tools

简单使用
  1. public class _10_ServiceWithToolsExample {
  2. // Please also check CustomerSupportApplication and CustomerSupportApplicationTest
  3. // from spring-boot-example module
  4. static class Calculator {
  5. @Tool("Calculates the length of a string")
  6. int stringLength(String s) {
  7. System.out.println("Called stringLength() with s='" + s + "'");
  8. return s.length();
  9. }
  10. @Tool("Calculates the sum of two numbers")
  11. int add(int a, int b) {
  12. System.out.println("Called add() with a=" + a + ", b=" + b);
  13. return a + b;
  14. }
  15. @Tool("Calculates the square root of a number")
  16. double sqrt(int x) {
  17. System.out.println("Called sqrt() with x=" + x);
  18. return Math.sqrt(x);
  19. }
  20. }
  21. interface Assistant {
  22. String chat(String userMessage);
  23. }
  24. public static void main(String[] args) {
  25. ChatLanguageModel model = OpenAiChatModel.builder()
  26. .baseUrl(ApiKeys.BASE_URL)
  27. .apiKey(ApiKeys.OPENAI_API_KEY)
  28. .logRequests(false)
  29. .build();
  30. Assistant assistant = AiServices.builder(Assistant.class)
  31. .chatLanguageModel(model)
  32. .tools(new Calculator())
  33. .chatMemory(MessageWindowChatMemory.withMaxMessages(10))
  34. .build();
  35. String question = "What is the square root of the sum of the numbers of letters in the words \"hello\" and \"world\"?";
  36. String answer = assistant.chat(question);
  37. System.out.println(answer);
  38. // The square root of the sum of the number of letters in the words "hello" and "world" is approximately 3.162.
  39. }
  40. }
  • @Tool: 添加对工具的描述, 告诉AI这个方法是的作用是什么
  • AiServices构建的时候添加tools类, 模型就知道这个工具什么时候调用
  • 当chat输入文本内容和tools中工具的方法含义相同时, 就会调用自定义的工具方法的函数进行处理得到结果

因为有些模型计算逻辑的处理并不是很好, 这样使用自定义的工具可以进行复杂的逻辑处理, AI只需要根据工具调用不同的方法拿到结果告诉用户即可

SpringBoot中进行使用

参考demo

GitHub - kvenLin/spring-langchain-demo: use LangChain4j dynamic generate meaningful test data for database

  1. spring.application.name=spring-langchain-demo
  2. langchain4j.open-ai.chat-model.api-key=${OPENAI_API_KEY}
  3. langchain4j.open-ai.chat-model.base-url=${OPENAI_API_URL}
  4. langchain4j.open-ai.chat-model.model-name=gpt-3.5-turbo
  5. langchain4j.open-ai.chat-model.temperature=0.7
  6. # 开启调用open-ai请求日志
  7. langchain4j.open-ai.chat-model.log-requests=true
  8. # 开启调用open-ai响应日志
  9. langchain4j.open-ai.chat-model.log-responses=true
  10. logging.level.dev.langchain4j=DEBUG
  11. logging.level.dev.ai4j.openai4j=DEBUG
  12. server.port=8081
  13. spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
  14. spring.datasource.url=jdbc:mysql://127.0.0.1:3306/spring-langchain-demo?useSSL=false&useUnicode=true&characterEncoding=UTF-8
  15. spring.datasource.username=root
  16. spring.datasource.password=123456
  17. # MyBatis-Plus configuration
  18. mybatis-plus.configuration.map-underscore-to-camel-case=true
  19. mybatis-plus.configuration.auto-mapping-behavior=full
  20. mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
  21. mybatis-plus.mapper-locations=classpath*:mapper/**/*Mapper.xml
  22. mybatis-plus.global-config.db-config.logic-not-delete-value=1
  23. mybatis-plus.global-config.db-config.logic-delete-value=0

这里的 ${OPENAI_API_KEY} ${OPENAI_API_URL} 可以用系统环境变量的方式提供

国内使用open-ai的模型有一定限制, 所以这里使用的是三方代理地址: F2API - OpenAI API Key

自定义配置:

  1. package com.louye.springlangchaindemo.config;
  2. import com.louye.springlangchaindemo.service.ai.AssistantService;
  3. import com.louye.springlangchaindemo.service.ai.Factory;
  4. import com.louye.springlangchaindemo.tool.AssistantTools;
  5. import dev.langchain4j.memory.chat.MessageWindowChatMemory;
  6. import dev.langchain4j.model.chat.ChatLanguageModel;
  7. import dev.langchain4j.model.openai.OpenAiChatModel;
  8. import dev.langchain4j.service.AiServices;
  9. import org.springframework.context.annotation.Bean;
  10. import org.springframework.context.annotation.Configuration;
  11. import static java.time.Duration.ofSeconds;
  12. @Configuration
  13. class AssistantConfiguration {
  14. @Bean
  15. AssistantService assistantService(ChatLanguageModel chatLanguageModel, AssistantTools assistantTools) {
  16. return AiServices.builder(AssistantService.class)
  17. .chatLanguageModel(chatLanguageModel)
  18. .chatMemory(MessageWindowChatMemory.builder()
  19. .maxMessages(10).build())
  20. .tools(assistantTools)
  21. .build();
  22. }
  23. @Bean
  24. Factory factoryService() {
  25. ChatLanguageModel chatLanguageModel = OpenAiChatModel.builder()
  26. .baseUrl(System.getenv("OPENAI_API_URL"))
  27. .apiKey(System.getenv("OPENAI_API_KEY"))
  28. .timeout(ofSeconds(60))
  29. // .responseFormat("json_object")
  30. .build();
  31. return AiServices.create(Factory.class, chatLanguageModel);
  32. }
  33. }

ai-service定义:

  1. package com.louye.springlangchaindemo.service.ai;
  2. import dev.langchain4j.service.SystemMessage;
  3. import dev.langchain4j.service.spring.AiService;
  4. @AiService
  5. public interface AssistantService {
  6. @SystemMessage("""
  7. you are system assistant, you can help me to do some works in this system.
  8. if user want to generate table data, must input the table name and the number of rows.
  9. """)
  10. String chat(String message);
  11. }
  1. public interface Factory {
  2. ProductDataList generateTestDataForProduct(TableDataGeneratePrompt prompt);
  3. CartDataList generateTestDataForCart(TableDataGeneratePrompt prompt);
  4. UserDataList generateTestDataForUser(TableDataGeneratePrompt prompt);
  5. }

tools自定义: 让用户提供表名和新增数据量, tools会根据用户指定的表去对该表新增测试数据

  1. package com.louye.springlangchaindemo.tool;
  2. import cn.hutool.core.collection.CollUtil;
  3. import cn.hutool.core.util.StrUtil;
  4. import com.louye.springlangchaindemo.domain.Product;
  5. import com.louye.springlangchaindemo.domain.aidata.CartDataList;
  6. import com.louye.springlangchaindemo.domain.aidata.ProductDataList;
  7. import com.louye.springlangchaindemo.domain.aidata.UserDataList;
  8. import com.louye.springlangchaindemo.service.CartService;
  9. import com.louye.springlangchaindemo.service.ProductService;
  10. import com.louye.springlangchaindemo.service.UserService;
  11. import com.louye.springlangchaindemo.service.ai.Factory;
  12. import com.louye.springlangchaindemo.template.TableDataGeneratePrompt;
  13. import dev.langchain4j.agent.tool.P;
  14. import dev.langchain4j.agent.tool.Tool;
  15. import jakarta.annotation.Resource;
  16. import lombok.extern.slf4j.Slf4j;
  17. import org.springframework.stereotype.Component;
  18. import java.time.LocalTime;
  19. import java.util.List;
  20. @Slf4j
  21. @Component
  22. public class AssistantTools {
  23. @Resource
  24. private Factory factory;
  25. @Resource
  26. private ProductService productService;
  27. @Resource
  28. private CartService cartService;
  29. @Resource
  30. private UserService userService;
  31. @Tool
  32. public String currentTime() {
  33. return LocalTime.now().toString();
  34. }
  35. @Tool("when user need to open the system")
  36. public String openSystem() {
  37. log.info("user need to open the system, do something here");
  38. return "success";
  39. }
  40. @Tool("when user need to generate test data for aim table")
  41. public String generateTestData(@P("tableName to generate test data") String tableName,
  42. @P("number of rows to generate") Integer num) {
  43. log.info("query table structure");
  44. String createTableDDL = userService.showTableDDL(tableName);
  45. if (StrUtil.isEmpty(createTableDDL)) {
  46. throw new RuntimeException("table not exisdt");
  47. }
  48. log.info("query table max id");
  49. Integer maxId = userService.maxIdForTable(tableName);
  50. TableDataGeneratePrompt prompt = new TableDataGeneratePrompt(tableName, num, maxId);
  51. if (tableName.equals("user")) {
  52. UserDataList userDataList = factory.generateTestDataForUser(prompt);
  53. log.info("userDataList: {}", userDataList);
  54. if (CollUtil.isNotEmpty(userDataList.getUserList())) {
  55. userService.saveBatch(userDataList.getUserList());
  56. }
  57. return userDataList.toString();
  58. } else if (tableName.equals("product")) {
  59. ProductDataList productDataList = factory.generateTestDataForProduct(prompt);
  60. log.info("productDataList: {}", productDataList);
  61. if (CollUtil.isNotEmpty(productDataList.getProductList())) {
  62. productService.saveBatch(productDataList.getProductList());
  63. }
  64. return productDataList.toString();
  65. }else if (tableName.equals("cart")) {
  66. CartDataList cartDataList = factory.generateTestDataForCart(prompt);
  67. log.info("cartDataList: {}", cartDataList);
  68. if (CollUtil.isNotEmpty(cartDataList.getCartList())) {
  69. cartService.saveBatch(cartDataList.getCartList());
  70. }
  71. return cartDataList.toString();
  72. }
  73. return "no handle tool for this table:" + tableName;
  74. }
  75. }

controller实现:

  1. package com.louye.springlangchaindemo.controller;
  2. import com.louye.springlangchaindemo.tool.AssistantTools;
  3. import com.louye.springlangchaindemo.service.ai.AssistantService;
  4. import jakarta.annotation.Resource;
  5. import lombok.extern.slf4j.Slf4j;
  6. import org.springframework.web.bind.annotation.GetMapping;
  7. import org.springframework.web.bind.annotation.RequestMapping;
  8. import org.springframework.web.bind.annotation.RequestParam;
  9. import org.springframework.web.bind.annotation.RestController;
  10. @Slf4j
  11. @RequestMapping("/assistant")
  12. @RestController
  13. class AssistantController {
  14. @Resource
  15. private AssistantService assistant;
  16. @Resource
  17. private AssistantTools assistantTools;
  18. @GetMapping("/chat")
  19. public String chat(@RequestParam(value = "message", defaultValue = "What is the time now?") String message) {
  20. log.info("AssistantController.chat() called with message: {}", message);
  21. return assistant.chat(message);
  22. }
  23. }

测试:

个人想法

后续AI的发展必然是AI-Agent的方向, 但是目前agent的工具大多都是提升生产力的工具, 而偏向系统使用方向的agent不太多, 感觉可能需要让AI明白一个系统如何使用并没有那么容易, 只有系统内部改造才能让AI明白什么时候调用什么函数, 这或许又涉及到业务重构等问题.

大方向上, 后续可能就不太需要用户再去在网站上点击操作了, 而是对话形式进行自己的业务处理改变数据库数据.但是这可能就涉及一些AI安全方向的, 可能这也是为什么目前为止还没有一些成熟的系统网站的agent的实现.
LangChain4j对于Java程序员来说, 更多的是提供了一种新的思路去设计系统的业务处理模式.期待后续LangChain4j的完善.

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/744844
推荐阅读
相关标签
  

闽ICP备14008679号