diff --git a/src/components/ai/AiButton.astro b/src/components/ai/AiButton.astro
index 39f9a5091..779830ffd 100644
--- a/src/components/ai/AiButton.astro
+++ b/src/components/ai/AiButton.astro
@@ -10,7 +10,7 @@ const t = useTranslations(Astro);
   <Button 
     size="large"
     class="rounded-3xl mr-4 text-base-100 min-w-[9rem]"
-    href="/docs/ai/get-started/"
+    href="https://java2ai.com"
     target="_blank"
     type="primary"
     iconClass="text-base-100"
diff --git a/src/components/ai/ArchitectureDiagram.astro b/src/components/ai/ArchitectureDiagram.astro
deleted file mode 100644
index d18a16674..000000000
--- a/src/components/ai/ArchitectureDiagram.astro
+++ /dev/null
@@ -1,24 +0,0 @@
----
-import { Headline } from "@serverless-cd/goat-ui";
-import { useTranslations } from "@i18n/util";
-
-const t = useTranslations(Astro);
----
-
-<div class="bg-secondary">
-  <div class="mx-auto choose-reason-ai-wrapper pt-[5rem]">
-    <Headline
-      title={t("home.website.architecture.diagram.description")}
-      tagline={t("home.website.architecture.diagram.title")}
-      titleTheme="neutral"
-      taglineTheme="info"
-    />
-    <div class="mx-auto max-w-[90rem] mt-[6.25rem]">
-      <img 
-        class="w-full lg:mx-h-[45.75rem]"
-        src="https://img.alicdn.com/imgextra/i2/O1CN01sON0wZ21yKROGt2SJ_!!6000000007053-2-tps-5440-2928.png" 
-        alt="ArchitectureDiagram"
-      />
-    </div>
-  </div>
-</div>
\ No newline at end of file
diff --git a/src/components/ai/CoreFeature.astro b/src/components/ai/CoreFeature.astro
deleted file mode 100644
index 3018fd461..000000000
--- a/src/components/ai/CoreFeature.astro
+++ /dev/null
@@ -1,92 +0,0 @@
----
-import { useTranslations } from "@i18n/util";
-import { Headline } from "@serverless-cd/goat-ui";
-import { CORE_FEATURE_LIST } from "@/constant";
-import { Aibox, Aibook, Aicen } from "../icon";
-	
-const t = useTranslations(Astro);
----
-
-<div class="bg-secondary">
-  <div class="mx-auto choose-reason-ai-wrapper pt-[5rem] max-w-[90rem]">
-    <Headline
-      tagline={t("home.website.core.features")}
-      title={t("home.website.ai.title")}
-      titleTheme="neutral"
-      taglineTheme="info"
-    />
-
-    <ul class="p-0 flex flex-wrap justify-center mt-[5rem]">
-      {
-          CORE_FEATURE_LIST.map((reason) => {
-            const { title, svgKey, description } = reason;
-            return (
-              <li class="card-item-wrapper relative list-none p-[1.5rem] rounded-[1.25rem]">
-                <div class="card-item-bg w-full h-full absolute top-0 left-0 rounded-[1.25rem]"></div>
-                <div class="card-item-icon rounded-[0.5rem]">
-                {(() => {
-                        switch (svgKey) {
-                          case "aibox":
-                            return <Aibox classes="fill-primary" />;
-                          case "aibook":
-                            return <Aibook classes="fill-primary" />;
-                          case "aicen":
-                            return <Aicen classes="fill-primary" />;
-                          default:
-                            return null;
-                        }
-                  })()}
-                </div>
-
-                <div class="py-4 text-neutral text-[1.125rem] leading-4">
-                  {t(title)}
-                </div>
-
-                <p class="text-info text-sm" set:html={t(description)} />
-              </li>
-            );
-          })
-      }
-    </ul>
-  </div>
-</div>
-
-
-
-<style is:global>
-  .choose-reason-ai-wrapper {
-    .card-item-wrapper {
-      margin-right: 1rem;
-      overflow: none;
-      flex: 1;
-    }
-    .card-item-bg {
-      background: linear-gradient(56deg, #9DD7A2 47%, #A5C6E6 100%, rgba(143, 168, 166, 0.47) 100%);
-      opacity: 0.3;
-    }
-
-    .card-item-wrapper:last-of-type {
-      margin-right: 0;
-    }
-
-    @media (max-width: 65rem) {
-      .card-item-wrapper {
-        max-width: 100%;
-        width: 100%;
-        margin: 0 1rem 1rem;
-        flex: 0 1 auto;
-      }
-      .card-item-wrapper:last-of-type {
-        margin-right: 1rem;
-      }
-    }
-
-    .card-item-icon {
-      background: theme("colors.primary");
-      width: 3rem;
-      height: 3rem;
-      line-height: 4rem;
-      text-align: center;
-    }
-  }
-</style>
diff --git a/src/components/ai/Footer.astro b/src/components/ai/Footer.astro
deleted file mode 100644
index 350b8e15d..000000000
--- a/src/components/ai/Footer.astro
+++ /dev/null
@@ -1,305 +0,0 @@
----
-import { useTranslations } from "@i18n/util";
-import { LinkButton } from "@serverless-cd/goat-ui"
-const t = useTranslations(Astro);
-const friendLinks = [
-  { 
-    label: 'Nacos', 
-    link: 'https://nacos.io/' 
-  },
-  { 
-    label: 'SpringCloudAlibaba', 
-    link: 'https://sca.aliyun.com/' 
-  },
-  { 
-    label: 'Arthas', 
-    link: 'https://arthas.aliyun.com/' 
-  },
-  { 
-    label: 'Dubbo', 
-    link: 'https://cn.dubbo.apache.org/zh-cn/' 
-  },
-  { 
-    label: 'Sentinel', 
-    link: 'http://sentinelguard.io' 
-  },
-  { 
-    label: 'Higress', 
-    link: 'https://higress.cn/' 
-  },
-  { 
-    label: 'RocketMQ', 
-    link: 'https://rocketmq.io/' 
-  },
-  { 
-    label: '可观测中文', 
-    link: 'https://observability.cn/' 
-  },
-  { 
-    label: 'OpenKruise', 
-    link: 'https://openkruise.io/' 
-  },
-  { 
-    label: 'serverless-devs', 
-    link: 'https://www.serverless-devs.com/' 
-  },
-];
----
-
-<footer-layout
-  class="home-footer w-full bg-secondary flex flex-col items-center py-10 pt-[5rem]"
->
-  <slot name="after-footer" />
-  <div
-    class="footer-top flex-col flex bg-error rounded-2xl text-center lg:flex-row"
-  >
-    <div class="footer-left flex flex-col gap-0 text-left my-9 ml-10 max-w-2xl">
-      <p
-        class="footer-left-title text-neutral text-[1.75rem] leading-9 lg:w-[25.9375rem] lg:h-10"
-      >
-        <b class="font-light">{t("commmon.footer.title")}</b>
-      </p>
-      <p
-        class="footer_left_des flex-1 text-neutral text-[0.875rem] w-[42rem] h-[4.5rem] mt-4 mb-[3rem]"
-      >
-        {t("commmon.footer.ai.description")}
-      </p>
-      <div class="flex">
-        <LinkButton  
-          href="https://github.com/alibaba/spring-ai-alibaba"
-          text="GitHub"    
-          theme="secondary"    
-          textTheme="neutral" 
-        />
-        
-        <div class="inline-block group relative ml-[1rem]">
-          <div class="hidden lg:block xl:block">
-            <div
-              class={`
-                  group inline-block border-none button-secondary bg-secondary
-                  btn transition-shadow ease-in-out duration-200
-                  flex items-center justify-center text-sm rounded-3xl no-underline 
-                  link-button-bg-secondary xp-large h-large
-                  rounded-3xl mr-4 text-neutral w-[9rem] font-light
-              `}
-            >
-              DING
-              <div class="absolute bottom-0 left-0 opacity-0 w-0 h-0 group-hover:opacity-100 group-hover:bottom-[3rem] group-hover:w-[22rem] group-hover:h-[21rem]">
-                <img 
-                  class="w-full h-full"
-                  alt="ding"
-                  src="https://img.alicdn.com/imgextra/i2/O1CN01qZY6WJ25tz9FzTxMi_!!6000000007585-2-tps-426-406.png"
-                />
-              </div>
-            </div>
-          </div>
-          
-          <div class="block lg:hidden xl:hidden">
-            <LinkButton  
-              class="md:hidden"
-              href={"https://img.alicdn.com/imgextra/i4/O1CN01ar15Ju1wDXuIxjk4s_!!6000000006274-2-tps-864-856.png"}
-              text="DING"    
-              theme="secondary"    
-              textTheme="neutral" 
-            />
-          </div>
-        </div>
-       </div>
-    </div>
-    <div
-      class="footer-right grid grid-cols-2 gap-2 flex text-left mt-9 ml-[9.625rem]"
-    >
-      <div>
-        <p
-          class="text-neutral text-[0.75rem] leading-4 tracking-[.15em] lg:mb-[3.0625rem]"
-        >
-          {t("commmon.footer.docs")}
-        </p>
-        <ul class="list-none w-[13.3125rem] h-4 ps-0 text-warning">
-          <li>
-            <a
-              href="#"
-              class="text-[.875rem] font-medium leading-5 tracking-normal mb-4 no-underline"
-            >
-              {t("commmon.footer.actions.overview")}
-            </a>
-          </li>
-          <li>
-            <a
-              href="/docs/ai/get-started/"
-              class="text-[.875rem] font-medium leading-5 tracking-normal mb-4 no-underline"
-            >
-              {t("commmon.footer.actions.start")}
-            </a>
-          </li>
-          <li>
-            <a
-              href="https://github.com/alibaba/spring-ai-alibaba"
-              target="_blank"
-              class="text-[.875rem] font-medium leading-5 tracking-normal mb-4 no-underline"
-            >
-              {t("commmon.footer.actions.guide")}
-            </a>
-          </li>
-        </ul>
-      </div>
-      <div>
-        <p
-          class="text-neutral text-[0.75rem] leading-4 tracking-[.15em] lg:mb-[3.0625rem]"
-        >
-          {t("commmon.footer.resource")}
-        </p>
-        <ul class="list-none w-full h-4 ps-0 text-warning">
-          <li>
-            <!-- TODO: 企业版链接 -->
-            <a
-              href="https://www.aliyun.com/product/aliware/mse"
-              target="_blank"
-              class="text-[.875rem] font-medium leading-5 tracking-normal mb-4 no-underline"
-            >
-              {t("commmon.footer.actions.enterprise")}
-            </a>
-          </li>
-        </ul>
-      </div>
-    </div>
-  </div>
-
-  <div
-    class="w-[90rem] self-center divider divider-vertical bg-muted mt-10 mb-0 h-[0.05rem]"
-  >
-  </div>
-  <!-- TODO: 底部水印 -->
-  <div
-    class="bottom_watermark text-[.875rem] text-info leading-6 text-center tracking-normal lg:pb-1 lg:pt-8"
-  >
-    <p class="text-neutral-500 flex pb-4 flex-wrap gap-2 lg:gap-4 justify-center">
-      <!-- 友情链接 -->
-      {t('commmon.footer.friend.link')}：
-      {
-        friendLinks.map(item => <a href={item.link} target="_blank" class="hover:text-primary transition-colors">{item.label}</a>)
-      }
-    </p>
-    © Spring Cloud Albaba Authors 2024 | Documentation Distributed under <a
-      href="https://creativecommons.org/licenses/by/4.0"
-      target="_blank">CC-BY-4.0</a
-    >
-    <br />
-     Copyright © 2017-2024, Alibaba. All rights reserved. Alibaba has
-    registered trademarks and uses trademarks.
-  </div>
-</footer-layout>
-
-<style is:global>
-  footer-layout {
-    a {
-      text-decoration: none; /* 清除下划线等默认样式 */
-      color: inherit; /* 继承父元素的颜色 */
-    }
-    .footer-top {
-      width: 90rem;
-    }
-    @media (min-width: 50rem) and (max-width: 86rem) {
-      .home-footer {
-        padding: 2.5rem;
-      }
-      .footer-top {
-        height: auto;
-        width: 100%;
-        min-height: 28rem;
-      }
-      .footer-right {
-        margin-left: 2.5rem;
-        margin-bottom: 2rem;
-      }
-      .footer-left-button {
-        margin: 1rem 0rem;
-      }
-      .footer-right > div {
-        height: auto;
-      }
-      .footer-right p {
-        margin-bottom: 2rem;
-      }
-      .footer-right ul {
-        height: 100%;
-      }
-      .divider-vertical {
-        width: 100%;
-      }
-    }
-    @media (max-width: 50rem) {
-      .home-footer {
-        padding: 1.5rem !important;
-      }
-      .footer-top {
-        /* align-items: center; */
-        min-height: 28rem;
-        padding: 1.5rem;
-        height: auto;
-        width: 100%;
-      }
-
-      .footer-left {
-        width: 100%;
-        margin-left: 0;
-        margin-bottom: 1rem;
-        margin-top: 0;
-      }
-
-      .footer-left p {
-        margin: 0rem 0rem 1rem 0rem;
-        width: auto;
-        height: auto;
-      }
-      .footer-left-title {
-        font-size: 1.125rem;
-      }
-      .footer-left-des {
-        font-size: 0.875rem;
-      }
-
-      .footer-left-button {
-        margin: 1rem 0rem;
-        width: 6rem;
-        height: 2rem;
-        min-height: 2rem;
-        padding-left: 0.75rem;
-        padding-right: 0.75rem;
-      }
-
-      .footer-right {
-        width: 100%;
-        margin: 0rem !important;
-        padding-top: 0rem;
-        overflow: hidden;
-      }
-
-      .footer-right > div {
-        margin-right: 1rem;
-        margin-bottom: 1rem;
-        width: 8.25rem;
-        height: auto;
-      }
-
-      .footer-right p {
-        width: 8.25rem;
-        margin-right: 1rem;
-        margin-bottom: 1rem;
-      }
-      .footer-right ul {
-        height: 100%;
-      }
-      .footer-right a {
-        font-size: 0.75rem !important;
-      }
-      .bottom_watermark {
-        margin: 0rem 0.5rem;
-        padding: 0.5rem 0rem;
-      }
-      .divider-vertical {
-        width: 100%;
-      }
-    }
-  }
-</style>
diff --git a/src/components/ai/HomeIntroduce.astro b/src/components/ai/HomeIntroduce.astro
deleted file mode 100644
index 6b02b8fb8..000000000
--- a/src/components/ai/HomeIntroduce.astro
+++ /dev/null
@@ -1,74 +0,0 @@
----
-import { useTranslations } from "@i18n/util";
-import AiButton from "@components/ai/AiButton.astro";
-
-const t = useTranslations(Astro);
----
-
-<div class="bg-secondary ai-introduce">
-  <div class="max-w-[90rem] min-h-[500px] mx-auto relative home-ailink">
-    <ai-home-introduce class="block md:w-full h-full flex">
-      <div class="absolute pl-[2.5rem]">
-        <h1 class="cursor-pointer xl:pt-[8.625rem] lg:pt-[6.625rem] md:pt-[10rem] pt-[7.625rem] xl:text-[4.5rem] lg:text-[4rem] md:text-[3.5rem] sm:text-[3rem] text-[2rem] text-neutral">
-          Spring AI Alibaba
-        </h1>
-        <p class=`cursor-pointer leading-[5rem] text-neutral mb-8 xl:text-[2rem] lg:text-[2rem] md:text-[2rem] sm:text-[1.5rem] text-[1rem]`>
-            {t('home.website.ai.quickly.develop')}
-        </p>
-        <AiButton />
-      </div>
-    </ai-home-introduce>
-  </div>
-</div>
-
-<script>
-  class AiHomeIntroduce extends HTMLElement {
-    constructor() {
-      super();
-      this.addEventListener("click", (event) => {
-        if (event.target.tagName.toLowerCase() !== 'a') {
-          this.goSCAhome()
-        }
-      });
-    }
-
-    goSCAhome = () => {
-      window.open('https://sca.aliyun.com');
-    } 
-  }
-
-  customElements.define("ai-home-introduce", AiHomeIntroduce);
-</script>
-
-<style is:global>
-.ai-introduce {
-  .home-ailink {
-      background: url('https://img.alicdn.com/imgextra/i3/O1CN01MLx4AB1MAxV8Z6pGh_!!6000000001395-0-tps-5760-2000.jpg') no-repeat;
-      background-size: cover;
-      background-position: 0 0;
-  }
-
-  @media (max-width: 50rem) {
-    .home-ailink {
-      /* background-position: -15rem 0!important; */
-      background: url('https://img.alicdn.com/imgextra/i4/O1CN01EH1c9x1Xw62QgLKke_!!6000000002987-0-tps-3120-2928.jpg') no-repeat;
-      background-size: cover;
-      background-position: 0 0;
-      min-height: 500px;
-    }
-  }
-  @media (min-width: 50rem) and (max-width: 65rem) {
-    .home-ailink {
-      background: url('https://img.alicdn.com/imgextra/i4/O1CN01EH1c9x1Xw62QgLKke_!!6000000002987-0-tps-3120-2928.jpg') no-repeat;
-      background-size: cover;
-      background-position: 0 -5rem;
-      min-height: 500px;
-    }
-  }
-  @media (min-width: 65rem) and (max-width: 80rem) {
-    .home-ailink {
-      background-position: -5rem 0;
-    }
-  }
-}
-</style>
\ No newline at end of file
diff --git a/src/components/common/Header/navbar.ts b/src/components/common/Header/navbar.ts
index a40edf9e9..019a986e2 100644
--- a/src/components/common/Header/navbar.ts
+++ b/src/components/common/Header/navbar.ts
@@ -56,14 +56,4 @@ export default [
     relativePosition: 'page',
     activePath: ["/learn"],
   },
-  {
-    label: "Spring AI Alibaba",
-    translations: {
-      en: "Spring AI Alibaba",
-    },
-    trigger: "click",
-    target: "_self",
-    route: "/ai/",
-    activePath: ["/ai/"],
-  },
 ];
\ No newline at end of file
diff --git a/src/components/home/HomeIntroduce.astro b/src/components/home/HomeIntroduce.astro
index 714400cfe..744c9273b 100644
--- a/src/components/home/HomeIntroduce.astro
+++ b/src/components/home/HomeIntroduce.astro
@@ -22,7 +22,7 @@ const { stargazers_count=0, forks_count=0 }:StarAndForkT = await sendFetch("http
     >
         <div slot="prev" class="block w-full min-h-[500] flex banner-toai max-w-[90rem]">
           <a
-              href="/ai/" 
+              href="https://java2ai.com/"
               target="_blank"
               class="block w-full"
           >
diff --git a/src/constant.ts b/src/constant.ts
index edf5fdb4f..7c6fd8713 100644
--- a/src/constant.ts
+++ b/src/constant.ts
@@ -448,13 +448,6 @@ export const ProductDisplayCardData = [
     body: "home.introduction.card.Seata.des",
     href: "docs/2023/user-guide/seata/quick-start/",
   },
-  {
-    cover: "https://img.alicdn.com/imgextra/i2/O1CN01HzKXZY29J7h0UIGJ5_!!6000000008046-0-tps-1000-1500.jpg",
-    coverPosition: "bottom",
-    title: "Spring AI",
-    body: "home.introduction.card.AI.des",
-    href: "docs/2023/user-guide/ai/quick-start/",
-  },
   {
     cover: "https://img.alicdn.com/imgextra/i2/O1CN01k1amBw1U0RHtPPlvH_!!6000000002455-0-tps-1000-1500.jpg",
     coverPosition: "bottom",
diff --git a/src/content/docs/2023/en/user-guide/ai/overview.md b/src/content/docs/2023/en/user-guide/ai/overview.md
deleted file mode 100644
index fdff60779..000000000
--- a/src/content/docs/2023/en/user-guide/ai/overview.md
+++ /dev/null
@@ -1,67 +0,0 @@
----
-title: AI 概述
-keywords: [Spring Cloud Alibaba,Spring AI,Tongyi Qianwen]
-description: "Spring AI 与通义千问集成，使用 Spring AI 开发 Java AI 应用。"
----
-
-## 1. 概览
-Spring 框架通过 Spring AI 项目正式发布了对生成式 AI 应用开发的支持。 Spring Cloud Alibaba 当前基于 Spring AI 提供了对阿里通义系列的完整支持，包括对话、prompt模板、Function Call、文生图、向量数据库等本。
-
-## 2. Spring AI 核心概念
-
-在开始之前，我们先回顾一下一些关键领域术语和概念。
-Spring AI 最初专注于设计用于处理语言输入和生成语言输出的模型。 该项目背后的想法是为开发人员提供一个抽象接口，这是将生成式 AI API 作为独立组件添加到应用程序中的基础。
-其中一种抽象是接口 AiClient，它有两个基本实现 - OpenAI 和 Azure OpenAI。而 Spring Cloud Alibaba AI 提供了对通义系列的全面支持。
-
-```
-public interface AiClient {
-    default String generate(String message);
-    AiResponse generate(Prompt prompt);
-}
-```
-
-AiClient为生成功能提供了两种选择。 简化的 -generate(String message) -使用 String 作为输入和输出，它可以用来避免 Promt 和 AiResponse 类的额外复杂性。
-现在，让我们仔细看看它们的区别。
-
-### 2.1. 高级特性 _Prompt_ 和 _AiResponse_
-
-在AI领域，提示是指提供给AI的短信。 它由上下文和问题组成，该模型用于生成答案。
-从 Spring AI 项目的角度来看，Prompt 是参数化_Message_s 的列表。
-
-```
-public class Prompt {
-    private final List<Message> messages;
-    // constructors and utility methods
-}
-
-public interface Message {
-    String getContent();
-    Map<String, Object> getProperties();
-    MessageType getMessageType();
-}
-```
-
-提示使开发人员能够更好地控制文本输入。 一个很好的例子是提示模板，它由预定义的文本和一组占位符构成。 然后，我们可以使用传递给 Message 构造函数的 Map<String, Object> 值来填充它们。
-
-Tell me a {adjective} joke about {content}.
-
-消息接口还保存有关 AI 模型可以处理的消息类别的高级信息。 例如，OpenAI 实现区分对话角色，并通过 MessageType 有效映射。 对于其他模型，它可以反映消息格式或一些其他自定义属性。 更多详情请参考官方文档。
-
-```
-public class AiResponse {
-    private final List<Generation> generations;
-    // getters and setters
-}
-
-public class Generation {
-    private final String text;
-    private Map<String, Object> info;
-}
-```
-
-AiResponse 由 Generation 对象列表组成，每个对象都保存相应提示的输出。 此外，Generation对象提供AI响应的元数据信息。
-
-
-
-关于 Spring Cloud Alibaba AI 的具体用法，请参考 [官方源码示例](https://github.com/alibaba/spring-cloud-alibaba/tree/2023.x/spring-cloud-alibaba-examples/spring-cloud-ai-example)。
-
diff --git a/src/content/docs/2023/en/user-guide/ai/quick-start.md b/src/content/docs/2023/en/user-guide/ai/quick-start.md
deleted file mode 100644
index 93d4c213f..000000000
--- a/src/content/docs/2023/en/user-guide/ai/quick-start.md
+++ /dev/null
@@ -1,172 +0,0 @@
----
-title: 快速开始
-keywords: [Spring Cloud Alibaba,Spring AI,Tongyi Qianwen]
-description: "Spring AI 与通义千问集成，使用 Spring AI 开发 Java AI 应用。"
----
-
-Spring AI 是 Spring 官方社区项目，旨在简化 Java AI 应用程序开发，让 Java 开发者像使用 Spring 开发普通应用一样开发 AI 应用。
-
-Spring Cloud Alibaba AI 以 Spring AI 为基础，并在此基础上提供阿里云通义系列大模型全面适配，让用户在 5 分钟内开发基于通义大模型的 Java AI 应用。
-
-## Spring AI 简介
-据 Spring AI 官网描述，该项目的灵感来自著名的 Python 项目，如 LangChain 和 LlamaIndex，但 Spring AI 并不是这些项目的直接复制。Spring AI 相信下一波 Generative AI 生成式应用程序将不仅面向 Python 开发人员，而且将在许多编程语言中无处不在。
-
-Spring AI 的核心是提供抽象，作为开发 Java AI 应用程序的基础，提供以下功能：
-
-- 提供多种大模型服务对接能力，包括业界大多数主流大模型服务等；
-- 支持灵活的 Prompt Template 和模型输出解析 Output Parsing 能力;
-- 支持多模态的生成式 AI 能力，如对话，文生图、文生语音等；
-- 提供通用的可移植的 API 以访问各类模型服务和 Embedding 服务，支持同步和流式调用，同时也支持传递特定模型的定制参数；
-- 支持 RAG 能力的基础组件，包括 DocumentLoader、TextSpillter、EmobeddingClient、VectorStore 等；
-- 支持 AI Spring Boot Starter 实现配置自动装配；
-## Spring Cloud Alibaba AI 简介
-Spring Cloud Alibaba AI 目前基于 [Spring AI 0.8.1](https://docs.spring.io/spring-ai/reference/0.8-SNAPSHOT/index.html) 版本 API 完成通义系列大模型的接入。通义接入是基于阿里云 [灵积模型服务](https://help.aliyun.com/zh/dashscope/)，灵积模型服务建立在“模型即服务”（Model-as-a-Service，MaaS）的理念基础之上，围绕 AI 各领域模型，通过标准化的API提供包括模型推理、模型微调训练在内的多种模型服务。
-
-在当前最新版本中，Spring Cloud Alibaba AI 主要完成了几种常见生成式模型的适配，包括对话、文生图、文生语音等，开发者可以使用 Spring Cloud Alibaba AI 开发基于通义的聊天、图片或语音生成 AI 应用，框架还提供 OutParser、Prompt Template、Stuff 等实用能力。
-
-以下是当前官方提供的 Spring Cloud Alibaba AI 应用开发示例，可以点击查看：
-
-- [聊天对话应用](https://github.com/alibaba/spring-cloud-alibaba/tree/2023.x/spring-cloud-alibaba-examples/ai-example/spring-cloud-ai-example/src/main/java/com/alibaba/cloud/ai/example/tongyi/service/impl/helloworld)
-- [文生图应用](https://github.com/alibaba/spring-cloud-alibaba/tree/2023.x/spring-cloud-alibaba-examples/ai-example/spring-cloud-ai-example/src/main/java/com/alibaba/cloud/ai/example/tongyi/service/impl/images)
-- [文生语音应用](https://github.com/alibaba/spring-cloud-alibaba/tree/2023.x/spring-cloud-alibaba-examples/ai-example/spring-cloud-ai-example/src/main/java/com/alibaba/cloud/ai/example/tongyi/service/impl/audio)
-- [模型输出解析OutputParser（实现从 String 到自动 POJO 映射）](https://github.com/alibaba/spring-cloud-alibaba/tree/2023.x/spring-cloud-alibaba-examples/ai-example/spring-cloud-ai-example/src/main/java/com/alibaba/cloud/ai/example/tongyi/service/impl/output)
-- [使用 Prompt Template](https://github.com/alibaba/spring-cloud-alibaba/tree/2023.x/spring-cloud-alibaba-examples/ai-example/spring-cloud-ai-example/src/main/java/com/alibaba/cloud/ai/example/tongyi/service/impl/prompttemplate)
-- [让 AI 模型接入外部数据（Prompt Stuff）](https://github.com/alibaba/spring-cloud-alibaba/tree/2023.x/spring-cloud-alibaba-examples/ai-example/spring-cloud-ai-example/src/main/java/com/alibaba/cloud/ai/example/tongyi/service/impl/stuff)
-
-## 体验第一个Spring AI应用开发
-
-本项目演示如何使用 `spring-cloud-starter-alibaba-ai` 完成一个在线聊天 AI 应用，底层使用通义千问提供的模型服务。可在此查看 [完整示例源码](https://github.com/alibaba/spring-cloud-alibaba/tree/2023.x/spring-cloud-alibaba-examples/ai-example/spring-cloud-ai-example/src/main/java/com/alibaba/cloud/ai/example/tongyi/service/impl/helloworld)。
-
-### 开发聊天对话应用
-
-1.  在项目 pom.xml 中加入 2023.0.1.0 版本 Spring Cloud Alibaba 依赖：
-```xml
-<dependencyManagement>
-  <dependencies>
-    <dependency>
-      <groupId>com.alibaba.cloud</groupId>
-      <artifactId>spring-cloud-alibaba-dependencies</artifactId>
-      <version>2023.0.1.0</version>
-      <type>pom</type>
-      <scope>import</scope>
-     </dependency>
-   </dependencies>
-</dependencyManagement>
-
-<dependencies>
-  <dependency>
-      <groupId>com.alibaba.cloud</groupId>
-      <artifactId>spring-cloud-starter-alibaba-ai</artifactId>
-  </dependency>
-</dependencies>
-```
-
-
-2.  在 `application.yml` 配置文件中加入以下配置：
-```yaml
-spring:
-  cloud:
-    ai:
-      tongyi:
-        chat:
-          options:
-            # Replace the following key with a valid API-KEY.
-            api-key: sk-a3d73b1709bf4a178c28ed7c8b3b5axx
-```
-
-
-3.  编写聊天服务实现类，由 Spring AI 自动注入 `ChatClient`、`StreamingChatClient`，`ChatClient` 屏蔽底层通义大模型交互细节。
-```java
-@Service
-public class TongYiSimpleServiceImpl extends AbstractTongYiServiceImpl {
-
-	private final ChatClient chatClient;
-
-	private final StreamingChatClient streamingChatClient;
-
-	@Autowired
-	public TongYiSimpleServiceImpl(ChatClient chatClient, StreamingChatClient streamingChatClient) {
-		this.chatClient = chatClient;
-		this.streamingChatClient = streamingChatClient;
-	}
-}
-```
-
-4. 提供具体聊天逻辑实现
-```java
-@Service
-public class TongYiSimpleServiceImpl extends AbstractTongYiServiceImpl {
-
-	// ......
-
-	@Override
-	public String completion(String message) {
-
-		Prompt prompt = new Prompt(new UserMessage(message));
-
-		return chatClient.call(prompt).getResult().getOutput().getContent();
-	}
-
-	@Override
-	public Map<String, String> streamCompletion(String message) {
-
-		StringBuilder fullContent = new StringBuilder();
-
-		streamingChatClient.stream(new Prompt(message))
-				.flatMap(chatResponse -> Flux.fromIterable(chatResponse.getResults()))
-				.map(content -> content.getOutput().getContent())
-				.doOnNext(fullContent::append)
-				.last()
-				.map(lastContent -> Map.of(message, fullContent.toString()))
-				.block();
-
-		log.info(fullContent.toString());
-
-		return Map.of(message, fullContent.toString());
-	}
-
-}
-```
-
-5. 编写 Spring 入口类并启动应用
-```java
-@SpringBootApplication
-public class TongYiApplication {
-	public static void main(String[] args) {
-		SpringApplication.run(TongYiApplication.class);
-	}
-}
-```
-
-至此，便完成了最简单的聊天 AI 应用开发，与普通的 Spring Boot 应用开发步骤完全一致！
-### 验证应用效果
-启动应用后，可通过如下两种方式验证应用效果。
-
-1. **方式一**
-
-
-浏览器地址栏输入：`http://localhost:8080/ai/example`
-
-返回如下响应：
-```json
-{
-    "Tell me a joke": "Sure, here's a classic one for you:\n\nWhy was the math book sad?\n\nBecause it had too many problems.\n\nI hope that made you smile! If you're looking for more, just let me know."
-}
-```
-
-
-2. **方式二**
-
-进入 `resources/static` 目录下，使用浏览器打开 index.html 文件，输入问题，即可获得输出响应（确保 api-key 有效）：
-
-![spring-ai-example](/img/user/ai/sca-ai-example-front.gif)
-
-### 申请通义API-KEY
-为使示例能够正常接入通义大模型，需要在阿里云开通 **DashScope 灵积模型服务**，申请有效的 API-KEY 并更新到应用配置文件。具体操作步骤可参见如下文档：
-
-[https://help.aliyun.com/zh/dashscope/developer-reference/activate-dashscope-and-create-an-api-key](https://help.aliyun.com/zh/dashscope/developer-reference/activate-dashscope-and-create-an-api-key)
-
-## 未来规划
-当前版本 Spring Cloud Alibaba AI 主要完成了几种常见生成式模型适配，包括对话、文生图、文生语音等。接下来的版本中，我们将继续完成 VectorStore、Embedding、ETL Pipeline 等更多适配，简化 RAG 等更多 AI 应用开发场景。
-
-![spring-ai-etl-pipeline](/img/user/ai/etl-pipeline.png)
diff --git a/src/content/docs/2023/zh-cn/user-guide/ai/overview.md b/src/content/docs/2023/zh-cn/user-guide/ai/overview.md
deleted file mode 100644
index fdff60779..000000000
--- a/src/content/docs/2023/zh-cn/user-guide/ai/overview.md
+++ /dev/null
@@ -1,67 +0,0 @@
----
-title: AI 概述
-keywords: [Spring Cloud Alibaba,Spring AI,Tongyi Qianwen]
-description: "Spring AI 与通义千问集成，使用 Spring AI 开发 Java AI 应用。"
----
-
-## 1. 概览
-Spring 框架通过 Spring AI 项目正式发布了对生成式 AI 应用开发的支持。 Spring Cloud Alibaba 当前基于 Spring AI 提供了对阿里通义系列的完整支持，包括对话、prompt模板、Function Call、文生图、向量数据库等本。
-
-## 2. Spring AI 核心概念
-
-在开始之前，我们先回顾一下一些关键领域术语和概念。
-Spring AI 最初专注于设计用于处理语言输入和生成语言输出的模型。 该项目背后的想法是为开发人员提供一个抽象接口，这是将生成式 AI API 作为独立组件添加到应用程序中的基础。
-其中一种抽象是接口 AiClient，它有两个基本实现 - OpenAI 和 Azure OpenAI。而 Spring Cloud Alibaba AI 提供了对通义系列的全面支持。
-
-```
-public interface AiClient {
-    default String generate(String message);
-    AiResponse generate(Prompt prompt);
-}
-```
-
-AiClient为生成功能提供了两种选择。 简化的 -generate(String message) -使用 String 作为输入和输出，它可以用来避免 Promt 和 AiResponse 类的额外复杂性。
-现在，让我们仔细看看它们的区别。
-
-### 2.1. 高级特性 _Prompt_ 和 _AiResponse_
-
-在AI领域，提示是指提供给AI的短信。 它由上下文和问题组成，该模型用于生成答案。
-从 Spring AI 项目的角度来看，Prompt 是参数化_Message_s 的列表。
-
-```
-public class Prompt {
-    private final List<Message> messages;
-    // constructors and utility methods
-}
-
-public interface Message {
-    String getContent();
-    Map<String, Object> getProperties();
-    MessageType getMessageType();
-}
-```
-
-提示使开发人员能够更好地控制文本输入。 一个很好的例子是提示模板，它由预定义的文本和一组占位符构成。 然后，我们可以使用传递给 Message 构造函数的 Map<String, Object> 值来填充它们。
-
-Tell me a {adjective} joke about {content}.
-
-消息接口还保存有关 AI 模型可以处理的消息类别的高级信息。 例如，OpenAI 实现区分对话角色，并通过 MessageType 有效映射。 对于其他模型，它可以反映消息格式或一些其他自定义属性。 更多详情请参考官方文档。
-
-```
-public class AiResponse {
-    private final List<Generation> generations;
-    // getters and setters
-}
-
-public class Generation {
-    private final String text;
-    private Map<String, Object> info;
-}
-```
-
-AiResponse 由 Generation 对象列表组成，每个对象都保存相应提示的输出。 此外，Generation对象提供AI响应的元数据信息。
-
-
-
-关于 Spring Cloud Alibaba AI 的具体用法，请参考 [官方源码示例](https://github.com/alibaba/spring-cloud-alibaba/tree/2023.x/spring-cloud-alibaba-examples/spring-cloud-ai-example)。
-
diff --git a/src/content/docs/2023/zh-cn/user-guide/ai/quick-start.md b/src/content/docs/2023/zh-cn/user-guide/ai/quick-start.md
deleted file mode 100644
index 93d4c213f..000000000
--- a/src/content/docs/2023/zh-cn/user-guide/ai/quick-start.md
+++ /dev/null
@@ -1,172 +0,0 @@
----
-title: 快速开始
-keywords: [Spring Cloud Alibaba,Spring AI,Tongyi Qianwen]
-description: "Spring AI 与通义千问集成，使用 Spring AI 开发 Java AI 应用。"
----
-
-Spring AI 是 Spring 官方社区项目，旨在简化 Java AI 应用程序开发，让 Java 开发者像使用 Spring 开发普通应用一样开发 AI 应用。
-
-Spring Cloud Alibaba AI 以 Spring AI 为基础，并在此基础上提供阿里云通义系列大模型全面适配，让用户在 5 分钟内开发基于通义大模型的 Java AI 应用。
-
-## Spring AI 简介
-据 Spring AI 官网描述，该项目的灵感来自著名的 Python 项目，如 LangChain 和 LlamaIndex，但 Spring AI 并不是这些项目的直接复制。Spring AI 相信下一波 Generative AI 生成式应用程序将不仅面向 Python 开发人员，而且将在许多编程语言中无处不在。
-
-Spring AI 的核心是提供抽象，作为开发 Java AI 应用程序的基础，提供以下功能：
-
-- 提供多种大模型服务对接能力，包括业界大多数主流大模型服务等；
-- 支持灵活的 Prompt Template 和模型输出解析 Output Parsing 能力;
-- 支持多模态的生成式 AI 能力，如对话，文生图、文生语音等；
-- 提供通用的可移植的 API 以访问各类模型服务和 Embedding 服务，支持同步和流式调用，同时也支持传递特定模型的定制参数；
-- 支持 RAG 能力的基础组件，包括 DocumentLoader、TextSpillter、EmobeddingClient、VectorStore 等；
-- 支持 AI Spring Boot Starter 实现配置自动装配；
-## Spring Cloud Alibaba AI 简介
-Spring Cloud Alibaba AI 目前基于 [Spring AI 0.8.1](https://docs.spring.io/spring-ai/reference/0.8-SNAPSHOT/index.html) 版本 API 完成通义系列大模型的接入。通义接入是基于阿里云 [灵积模型服务](https://help.aliyun.com/zh/dashscope/)，灵积模型服务建立在“模型即服务”（Model-as-a-Service，MaaS）的理念基础之上，围绕 AI 各领域模型，通过标准化的API提供包括模型推理、模型微调训练在内的多种模型服务。
-
-在当前最新版本中，Spring Cloud Alibaba AI 主要完成了几种常见生成式模型的适配，包括对话、文生图、文生语音等，开发者可以使用 Spring Cloud Alibaba AI 开发基于通义的聊天、图片或语音生成 AI 应用，框架还提供 OutParser、Prompt Template、Stuff 等实用能力。
-
-以下是当前官方提供的 Spring Cloud Alibaba AI 应用开发示例，可以点击查看：
-
-- [聊天对话应用](https://github.com/alibaba/spring-cloud-alibaba/tree/2023.x/spring-cloud-alibaba-examples/ai-example/spring-cloud-ai-example/src/main/java/com/alibaba/cloud/ai/example/tongyi/service/impl/helloworld)
-- [文生图应用](https://github.com/alibaba/spring-cloud-alibaba/tree/2023.x/spring-cloud-alibaba-examples/ai-example/spring-cloud-ai-example/src/main/java/com/alibaba/cloud/ai/example/tongyi/service/impl/images)
-- [文生语音应用](https://github.com/alibaba/spring-cloud-alibaba/tree/2023.x/spring-cloud-alibaba-examples/ai-example/spring-cloud-ai-example/src/main/java/com/alibaba/cloud/ai/example/tongyi/service/impl/audio)
-- [模型输出解析OutputParser（实现从 String 到自动 POJO 映射）](https://github.com/alibaba/spring-cloud-alibaba/tree/2023.x/spring-cloud-alibaba-examples/ai-example/spring-cloud-ai-example/src/main/java/com/alibaba/cloud/ai/example/tongyi/service/impl/output)
-- [使用 Prompt Template](https://github.com/alibaba/spring-cloud-alibaba/tree/2023.x/spring-cloud-alibaba-examples/ai-example/spring-cloud-ai-example/src/main/java/com/alibaba/cloud/ai/example/tongyi/service/impl/prompttemplate)
-- [让 AI 模型接入外部数据（Prompt Stuff）](https://github.com/alibaba/spring-cloud-alibaba/tree/2023.x/spring-cloud-alibaba-examples/ai-example/spring-cloud-ai-example/src/main/java/com/alibaba/cloud/ai/example/tongyi/service/impl/stuff)
-
-## 体验第一个Spring AI应用开发
-
-本项目演示如何使用 `spring-cloud-starter-alibaba-ai` 完成一个在线聊天 AI 应用，底层使用通义千问提供的模型服务。可在此查看 [完整示例源码](https://github.com/alibaba/spring-cloud-alibaba/tree/2023.x/spring-cloud-alibaba-examples/ai-example/spring-cloud-ai-example/src/main/java/com/alibaba/cloud/ai/example/tongyi/service/impl/helloworld)。
-
-### 开发聊天对话应用
-
-1.  在项目 pom.xml 中加入 2023.0.1.0 版本 Spring Cloud Alibaba 依赖：
-```xml
-<dependencyManagement>
-  <dependencies>
-    <dependency>
-      <groupId>com.alibaba.cloud</groupId>
-      <artifactId>spring-cloud-alibaba-dependencies</artifactId>
-      <version>2023.0.1.0</version>
-      <type>pom</type>
-      <scope>import</scope>
-     </dependency>
-   </dependencies>
-</dependencyManagement>
-
-<dependencies>
-  <dependency>
-      <groupId>com.alibaba.cloud</groupId>
-      <artifactId>spring-cloud-starter-alibaba-ai</artifactId>
-  </dependency>
-</dependencies>
-```
-
-
-2.  在 `application.yml` 配置文件中加入以下配置：
-```yaml
-spring:
-  cloud:
-    ai:
-      tongyi:
-        chat:
-          options:
-            # Replace the following key with a valid API-KEY.
-            api-key: sk-a3d73b1709bf4a178c28ed7c8b3b5axx
-```
-
-
-3.  编写聊天服务实现类，由 Spring AI 自动注入 `ChatClient`、`StreamingChatClient`，`ChatClient` 屏蔽底层通义大模型交互细节。
-```java
-@Service
-public class TongYiSimpleServiceImpl extends AbstractTongYiServiceImpl {
-
-	private final ChatClient chatClient;
-
-	private final StreamingChatClient streamingChatClient;
-
-	@Autowired
-	public TongYiSimpleServiceImpl(ChatClient chatClient, StreamingChatClient streamingChatClient) {
-		this.chatClient = chatClient;
-		this.streamingChatClient = streamingChatClient;
-	}
-}
-```
-
-4. 提供具体聊天逻辑实现
-```java
-@Service
-public class TongYiSimpleServiceImpl extends AbstractTongYiServiceImpl {
-
-	// ......
-
-	@Override
-	public String completion(String message) {
-
-		Prompt prompt = new Prompt(new UserMessage(message));
-
-		return chatClient.call(prompt).getResult().getOutput().getContent();
-	}
-
-	@Override
-	public Map<String, String> streamCompletion(String message) {
-
-		StringBuilder fullContent = new StringBuilder();
-
-		streamingChatClient.stream(new Prompt(message))
-				.flatMap(chatResponse -> Flux.fromIterable(chatResponse.getResults()))
-				.map(content -> content.getOutput().getContent())
-				.doOnNext(fullContent::append)
-				.last()
-				.map(lastContent -> Map.of(message, fullContent.toString()))
-				.block();
-
-		log.info(fullContent.toString());
-
-		return Map.of(message, fullContent.toString());
-	}
-
-}
-```
-
-5. 编写 Spring 入口类并启动应用
-```java
-@SpringBootApplication
-public class TongYiApplication {
-	public static void main(String[] args) {
-		SpringApplication.run(TongYiApplication.class);
-	}
-}
-```
-
-至此，便完成了最简单的聊天 AI 应用开发，与普通的 Spring Boot 应用开发步骤完全一致！
-### 验证应用效果
-启动应用后，可通过如下两种方式验证应用效果。
-
-1. **方式一**
-
-
-浏览器地址栏输入：`http://localhost:8080/ai/example`
-
-返回如下响应：
-```json
-{
-    "Tell me a joke": "Sure, here's a classic one for you:\n\nWhy was the math book sad?\n\nBecause it had too many problems.\n\nI hope that made you smile! If you're looking for more, just let me know."
-}
-```
-
-
-2. **方式二**
-
-进入 `resources/static` 目录下，使用浏览器打开 index.html 文件，输入问题，即可获得输出响应（确保 api-key 有效）：
-
-![spring-ai-example](/img/user/ai/sca-ai-example-front.gif)
-
-### 申请通义API-KEY
-为使示例能够正常接入通义大模型，需要在阿里云开通 **DashScope 灵积模型服务**，申请有效的 API-KEY 并更新到应用配置文件。具体操作步骤可参见如下文档：
-
-[https://help.aliyun.com/zh/dashscope/developer-reference/activate-dashscope-and-create-an-api-key](https://help.aliyun.com/zh/dashscope/developer-reference/activate-dashscope-and-create-an-api-key)
-
-## 未来规划
-当前版本 Spring Cloud Alibaba AI 主要完成了几种常见生成式模型适配，包括对话、文生图、文生语音等。接下来的版本中，我们将继续完成 VectorStore、Embedding、ETL Pipeline 等更多适配，简化 RAG 等更多 AI 应用开发场景。
-
-![spring-ai-etl-pipeline](/img/user/ai/etl-pipeline.png)
diff --git a/src/content/docs/ai/_sidebar.json b/src/content/docs/ai/_sidebar.json
deleted file mode 100644
index f74296a57..000000000
--- a/src/content/docs/ai/_sidebar.json
+++ /dev/null
@@ -1,44 +0,0 @@
-[
-	{
-        "label": "概览",
-        "translations": {
-            "en": "Introduction"
-        },
-        "link": "docs/ai/overview/"
-    },
-    {
-        "label": "核心概念",
-        "translations": {
-            "en": "Concepts"
-        },
-        "link": "docs/ai/concepts/"
-	},
-    {
-        "label": "快速开始",
-        "translations": {
-            "en": "Quick Start"
-        },
-        "link": "docs/ai/get-started/"
-	},
-	{
-        "label": "使用教程",
-        "translations": {
-            "en": "Tutorials"
-        },
-        "autogenerate": {
-            "directory": "tutorials"
-        },
-        "items": []
-	},
-	{
-        "label": "最佳实践",
-        "translations": {
-            "en": "practices"
-        },
-        "autogenerate": {
-            "directory": "practices"
-        },
-        "items": []
-	}
-
-]
\ No newline at end of file
diff --git a/src/content/docs/ai/en/concepts.md b/src/content/docs/ai/en/concepts.md
deleted file mode 100644
index b034599be..000000000
--- a/src/content/docs/ai/en/concepts.md
+++ /dev/null
@@ -1,151 +0,0 @@
----
-title: 核心概念
-keywords: [Spring Cloud Alibaba核心概念, ]
-description: "Spring Cloud Alibaba核心概念"
----
-
-# 核心概念
-
-本节介绍 Spring AI 框架使用的核心概念。我们建议仔细阅读，以了解框架实现背后的思想。
-
-## 模型（Model）
-
-AI 模型是旨在处理和生成信息的算法，通常模仿人类的认知功能。通过从大型数据集中学习模式和见解，这些模型可以做出预测、文本、图像或其他输出，从而增强各个行业的各种应用。
-
-AI 模型有很多种，每种都适用于特定的用例。虽然 ChatGPT 及其生成 AI 功能通过文本输入和输出吸引了用户，但许多模型和公司都提供不同的输入和输出。在 ChatGPT 之前，许多人都对文本到图像的生成模型着迷，例如 Midjourney 和 Stable Diffusion。
-
-![spring-ai-concepts-model-types](https://img.alicdn.com/imgextra/i2/O1CN01otCVsl22MbQzFKYzJ_!!6000000007106-0-tps-2472-1618.jpg)
-
-Sprig AI 目前支持以语言、图像和音频形式处理输入和输出的模型。上表中的最后一行接受文本作为输入并输出数字，通常称为嵌入文本（Embedding Text），用来表示 AI 模型中使用的内部数据结构。Sprig AI 提供了对 Embedding 的支持以支持开发更高级的应用场景。
-
-GPT 等模型的独特之处在于其预训练特性，正如 GPT 中的“P”所示——Chat Generative Pre-trained Transformer。这种预训练功能将 AI 转变为通用的开发工具，开发者使用这种工具不再需要广泛的机器学习或模型训练背景。
-
-## 提示（Prompt）
-
-Prompt作为语言基础输入的基础，指导AI模型生成特定的输出。对于熟悉ChatGPT的人来说，Prompt似乎只是输入到对话框中的文本，然后发送到API。然而，它的内涵远不止于此。在许多AI模型中，Prompt的文本不仅仅是一个简单的字符串。
-
-ChatGPT的API包含多个文本输入，每个文本输入都有其角色。例如，系统角色用于告知模型如何行为并设定交互的背景。还有用户角色，通常是来自用户的输入。
-
-撰写有效的Prompt既是一门艺术，也是一门科学。ChatGPT旨在模拟人类对话，这与使用SQL“提问”有很大的区别。与AI模型的交流就像与另外一个人对话一样。
-
-这种互动风格的重要性使得“Prompt工程”这一学科应运而生。现在有越来越多的技术被提出，以提高Prompt的有效性。投入时间去精心设计Prompt可以显著改善生成的输出。
-
-分享Prompt已成为一种共同的实践，且正在进行积极的学术研究。例如，最近的一篇研究论文发现，最有效的Prompt之一可以以“深呼吸一下，分步进行此任务”开头。这表明语言的重要性之高。我们尚未完全了解如何充分利用这一技术的前几代版本，例如ChatGPT 3.5，更不用说正在开发的新版本了。
-
-### 提示词模板（Prompt Template）
-
-创建有效的Prompt涉及建立请求的上下文，并用用户输入的特定值替换请求的部分内容。这个过程使用传统的基于文本的模板引擎来进行Prompt的创建和管理。Spring AI采用开源库StringTemplate来实现这一目的。
-
-例如，考虑以下简单的Prompt模板：
-
-```text
-Tell me a {adjective} joke about {content}.
-```
-
-在Spring AI中，Prompt模板可以类比于Spring MVC架构中的“视图”。一个模型对象，通常是java.util.Map，提供给Template，以填充模板中的占位符。渲染后的字符串成为传递给AI模型的Prompt的内容。
-
-传递给模型的Prompt在具体数据格式上有相当大的变化。从最初的简单字符串开始，Prompt逐渐演变为包含多条消息的格式，其中每条消息中的每个字符串代表模型的不同角色。
-
-## 嵌入（Embedding）
-
-嵌入（Embedding）是文本、图像或视频的数值表示，能够捕捉输入之间的关系，Embedding通过将文本、图像和视频转换为称为向量（Vector）的浮点数数组来工作。这些向量旨在捕捉文本、图像和视频的含义，Embedding数组的长度称为向量的维度。
-
-通过计算两个文本片段的向量表示之间的数值距离，应用程序可以确定用于生成嵌入向量的对象之间的相似性。
-
-![spring-ai-embeddings](https://img.alicdn.com/imgextra/i1/O1CN01EnE3i61j2vin5eTGV_!!6000000004491-0-tps-3518-1136.jpg)
-
-作为一名探索人工智能的Java开发者，理解这些向量表示背后的复杂数学理论或具体实现并不是必需的。对它们在人工智能系统中的作用和功能有基本的了解就足够了，尤其是在将人工智能功能集成到您的应用程序中时。
-
-Embedding在实际应用中，特别是在检索增强生成（RAG）模式中，具有重要意义。它们使数据能够在语义空间中表示为点，这类似于欧几里得几何的二维空间，但在更高的维度中。这意味着，就像欧几里得几何中平面上的点可以根据其坐标的远近关系而接近或远离一样，在语义空间中，点的接近程度反映了意义的相似性。关于相似主题的句子在这个多维空间中的位置较近，就像图表上彼此靠近的点。这种接近性有助于文本分类、语义搜索，甚至产品推荐等任务，因为它允许人工智能根据这些点在扩展的语义空间中的“位置”来辨别和分组相关概念。
-
-您可以将这个语义空间视为一个向量。
-
-## Token
-
-token是 AI 模型工作原理的基石。输入时，模型将单词转换为token。输出时，它们将token转换回单词。
-
-在英语中，一个token大约对应一个单词的 75%。作为参考，莎士比亚的全集总共约 90 万个单词，翻译过来大约有 120 万个token。
-
-![spring-ai-concepts-tokens](https://img.alicdn.com/imgextra/i3/O1CN01ciNztT1nJCFhQodzH_!!6000000005068-2-tps-1345-246.png)
-
-也许更重要的是 “token = 金钱”。在托管 AI 模型的背景下，您的费用由使用的token数量决定。输入和输出都会影响总token数量。
-
-此外，模型还受到 token 限制，这会限制单个 API 调用中处理的文本量。此阈值通常称为“上下文窗口”。模型不会处理超出此限制的任何文本。
-
-例如，ChatGPT3 的token限制为 4K，而 GPT4 则提供不同的选项，例如 8K、16K 和 32K。Anthropic 的 Claude AI 模型的token限制为 100K，而 Meta 的最新研究则产生了 1M token限制模型。
-
-要使用 GPT4 总结莎士比亚全集，您需要制定软件工程策略来切分数据并在模型的上下文窗口限制内呈现数据。Spring AI 项目可以帮助您完成此任务。
-
-## 结构化输出（Structured Output）
-
-即使您要求回复为 JSON ，AI 模型的输出通常也会以 `java.lang.String` 的形式出现。它可能是正确的 JSON，但它可能并不是你想要的 JSON 数据结构，它只是一个字符串。此外，在提示词 Prompt 中要求 “返回JSON” 并非 100% 准确。
-
-这种复杂性导致了一个专门领域的出现，涉及创建 Prompt 以产生预期的输出，然后将生成的简单字符串转换为可用于应用程序集成的数据结构。
-
-![结构化输出转换器架构](https://img.alicdn.com/imgextra/i3/O1CN01lqCPAC1Xbwc1MfYv7_!!6000000002943-0-tps-2809-1423.jpg)
-
-[结构化输出转换](./tutorials/structured-output/)采用精心设计的提示，通常需要与模型进行多次交互才能实现所需的格式。
-
-## 将您的数据和 API 引入 AI 模型
-
-如何让人工智能模型与不在训练集中的数据一同工作？
-
-请注意，GPT 3.5/4.0 数据集仅支持截止到 2021 年 9 月之前的数据。因此，该模型表示它不知道该日期之后的知识，因此它无法很好的应对需要用最新知识才能回答的问题。一个有趣的小知识是，这个数据集大约有 650GB。
-
-有三种技术可以定制 AI 模型以整合您的数据：
-
-* `Fine Tuning` 微调：这种传统的机器学习技术涉及定制模型并更改其内部权重。然而，即使对于机器学习专家来说，这是一个具有挑战性的过程，而且由于 GPT 等模型的大小，它极其耗费资源。此外，有些模型可能不提供此选项。
-* `Prompt Stuffing` 提示词填充：一种更实用的替代方案是将您的数据嵌入到提供给模型的提示中。考虑到模型的令牌限制，我们需要具备过滤相关数据的能力，并将过滤出的数据填充到在模型交互的上下文窗口中，这种方法俗称“提示词填充”。Spring AI 库可帮助您基于“提示词填充” 技术，也称为[检索增强生成 (RAG)](./#检索增强生成rag)实现解决方案。
-
-![prompt-stuffing](https://img.alicdn.com/imgextra/i3/O1CN01hRUT291k1O09cdQEU_!!6000000004623-0-tps-3249-1230.jpg)
-
-* [Function Calling](./tutorials/function-calling/)：此技术允许注册自定义的用户函数，将大型语言模型连接到外部系统的 API。Spring AI 大大简化了支持[函数调用](./tutorials/function-calling/)所需编写的代码。
-
-
-### 检索增强生成（RAG）
-
-一种称为检索增强生成 (RAG) 的技术已经出现，旨在解决为 AI 模型提供额外的知识输入，以辅助模型更好的回答问题。
-
-该方法涉及批处理式的编程模型，其中涉及到：从文档中读取非结构化数据、对其进行转换、然后将其写入矢量数据库。从高层次上讲，这是一个 ETL（提取、转换和加载）管道。矢量数据库则用于 RAG 技术的检索部分。
-
-在将非结构化数据加载到矢量数据库的过程中，最重要的转换之一是将原始文档拆分成较小的部分。将原始文档拆分成较小部分的过程有两个重要步骤：
-
-1. 将文档拆分成几部分，同时保留内容的语义边界。例如，对于包含段落和表格的文档，应避免在段落或表格中间拆分文档；对于代码，应避免在方法实现的中间拆分代码。
-2. 将文档的各部分进一步拆分成大小仅为 AI 模型令牌 token 限制的一小部分的部分。
-
-
-RAG 的下一个阶段是处理用户输入。当用户的问题需要由 AI 模型回答时，问题和所有“类似”的文档片段都会被放入发送给 AI 模型的提示中。这就是使用矢量数据库的原因，它非常擅长查找具有一定相似度的“类似”内容。
-
-![Spring AI RAG](https://img.alicdn.com/imgextra/i1/O1CN01zEQSHu1sQ8KTQSA2E_!!6000000005760-0-tps-3360-1859.jpg)
-
-* <a target="_blank" href="https://docs.spring.io/spring-ai/reference/api/etl-pipeline.html">ETL 管道</a> 提供了有关协调从数据源提取数据并将其存储在结构化向量存储中的流程的更多信息，确保在将数据传递给 AI 模型时数据具有最佳的检索格式。
-* [ChatClient - RAG](./tutorials/chat-client/#检索增强生成rag) 解释了如何使用`QuestionAnswerAdvisor` Advisor 在您的应用程序中启用 RAG 功能。
-
-
-### 函数调用（Function Calling）
-
-大型语言模型 (LLM) 在训练后即被冻结，导致知识陈旧，并且无法访问或修改外部数据。
-
-[Function Calling](https://docs.spring.io/spring-ai/reference/api/functions.html)机制解决了这些缺点，它允许您注册自己的函数，以将大型语言模型连接到外部系统的 API。这些系统可以为 LLM 提供实时数据并代表它们执行数据处理操作。
-
-Spring AI 大大简化了您需要编写的代码以支持函数调用。它为您处理函数调用对话。您可以将函数作为提供，`@Bean`然后在提示选项中提供该函数的 bean 名称以激活该函数。此外，您可以在单个提示中定义和引用多个函数。
-
-![Spring AI Function Calling](https://img.alicdn.com/imgextra/i3/O1CN01kiQh6L1hnWmm5gCAW_!!6000000004322-0-tps-3400-1838.jpg)
-
-* （1）执行聊天请求并发送函数定义信息。后者提供`name`（`description`例如，解释模型何时应调用该函数）和`input parameters`（例如，函数的输入参数模式）。
-* （2）当模型决定调用该函数时，它将使用输入参数调用该函数，并将输出返回给模型。
-* （3）Spring AI 为您处理此对话。它将函数调用分派给适当的函数，并将结果返回给模型。
-* （4）模型可以执行多个函数调用来检索所需的所有信息。
-* （5）一旦获取了所有需要的信息，模型就会生成响应。
-
-请关注[函数调用](https://docs.spring.io/spring-ai/reference/api/functions.html)文档以获取有关如何在不同 AI 模型中使用此功能的更多信息。
-
-## 评估人工智能的回答（Evaluation）
-
-有效评估人工智能系统回答的正确性，对于确保最终应用程序的准确性和实用性非常重要，一些新兴技术使得预训练模型本身能够用于此目的。
-
-Evaluation 评估过程涉及分析响应是否符合用户的意图、与查询的上下文强相关，一些指标如相关性、连贯性和事实正确性等都被用于衡量 AI 生成的响应的质量。
-
-一种方法是把用户的请求、模型的响应一同作为输入给到模型服务，对比模型给的响应或回答是否与提供的响应数据一致。
-
-此外，利用矢量数据库（Vector Database）中存储的信息作为补充数据可以增强评估过程，有助于确定响应的相关性。
\ No newline at end of file
diff --git a/src/content/docs/ai/en/get-started.md b/src/content/docs/ai/en/get-started.md
deleted file mode 100644
index f4db9e69a..000000000
--- a/src/content/docs/ai/en/get-started.md
+++ /dev/null
@@ -1,121 +0,0 @@
----
-title: 快速开始
-keywords: [Spring AI,通义千问,百炼,智能体应用]
-description: "Spring AI 与通义千问集成，使用 Spring AI 开发 Java AI 应用。"
----
-
-Spring AI Alibaba 实现了与阿里云通义模型的完整适配，接下来，我们将学习如何使用 spring ai alibaba 开发一个基于通义模型服务的智能聊天应用。
-
-## 快速体验示例
-
-> 注意：因为 Spring AI Alibaba 基于 Spring Boot 3.x 开发，因此本地 JDK 版本要求为 17 及以上。
-
-1. 下载项目
-	运行以下命令下载源码，进入 helloworld 示例目录：
-
-	```shell
-	git clone --depth=1 https://github.com/alibaba/spring-ai-alibaba.git
-	cd spring-ai-alibaba/spring-ai-alibaba-examples/helloworld-example
-	```
-
-2. 运行项目
-	首先，需要获取一个合法的 API-KEY 并设置 `AI_DASHSCOPE_API_KEY` 环境变量，可跳转 <a target="_blank" href="https://help.aliyun.com/zh/model-studio/developer-reference/get-api-key">阿里云百炼平台</a> 了解如何获取 API-KEY。
-
-	```shell
-	export AI_DASHSCOPE_API_KEY=${REPLACE-WITH-VALID-API-KEY}
-	```
-
-	启动示例应用：
-
-	```shell
-	./mvnw compile exec:java -Dexec.mainClass="com.alibaba.cloud.ai.example.helloworld.HelloWorldExampleApplication"
-	```
-
-	访问 `http://localhost:8080/ai/chat?input=给我讲一个笑话吧`，向通义模型提问并得到回答。
-
-## 示例开发指南
-以上示例本质上就是一个普通的 Spring Boot 应用，我们来通过源码解析看一下具体的开发流程。
-
-1. 添加依赖
-
-	首先，需要在项目中添加 `spring-ai-alibaba-starter` 依赖，它将通过 Spring Boot 自动装配机制初始化与阿里云通义大模型通信的 `ChatClient`、`ChatModel` 相关实例。
-
-	```xml
-	<dependency>	
-		<groupId>com.alibaba.cloud.ai</groupId>
-		<artifactId>spring-ai-alibaba-starter</artifactId>
-		<version>1.0.0-M2.1</version>
-	</dependency>
-	```
-
-    > 注意：由于 spring-ai 相关依赖包还没有发布到中央仓库，如出现 spring-ai-core 等相关依赖解析问题，请在您项目的 pom.xml 依赖中加入如下仓库配置。
-    >
-    > ```xml
-    > <repositories>
-    > 	<repository>
-    > 		<id>spring-milestones</id>
-    > 		<name>Spring Milestones</name>
-    > 		<url>https://repo.spring.io/milestone</url>
-    > 		<snapshots>
-    > 			<enabled>false</enabled>
-    > 		</snapshots>
-    > 	</repository>
-    > </repositories>
-    > ```
-
-2. 注入 ChatClient
-
-	接下来，在普通 Controller Bean 中注入 `ChatClient` 实例，这样你的 Bean 就具备与 AI 大模型智能对话的能力了。
-
-	```java
-	@RestController
-    @RequestMapping("/ai")
-	public class ChatController {
-	
-		private final ChatClient chatClient;
-	
-		public ChatController(ChatClient.Builder builder) {
-			this.chatClient = builder.build();
-		}
-	
-		@GetMapping("/chat")
-		public String chat(String input) {
-			return this.chatClient.prompt()
-					.user(input)
-					.call()
-					.content();
-		}
-	}
-	```
-
-	以上示例中，ChatClient 调用大模型使用的是默认参数，Spring AI Alibaba 还支持通过 `DashScopeChatOptions` 调整与模型对话时的参数，`DashScopeChatOptions` 支持两种不同维度的配置方式：
-
-	1. 全局默认值，即 `ChatClient` 实例初始化参数
-
-		可以在 `application.yaml` 文件中指定 `spring.ai.dashscope.chat.options.*` 或调用构造函数 `ChatClient.Builder.defaultOptions(options)`、`DashScopeChatModel(api, options)` 完成配置初始化。
-
-	2. 每次 Prompt 调用前动态指定
-
-		```java
-		ChatResponse response = chatModel.call(
-			new Prompt(
-				"Generate the names of 5 famous pirates.",
-				DashScopeChatOptions.builder()
-					.withModel("qwen-plus")
-					.withTemperature(0.4F)
-				.build()
-			));
-		```
-
-	关于 `DashScopeChatOptions` 配置项的详细说明，请查看参考手册。
-
-## 更多资料
-### 基础示例与API使用
-* [ChatClient 详细说明](./tutorials/chat-client/)
-* [Prompt Template 提示词模板](./tutorials/prompt/)
-* [Function Calling](./tutorials/function-calling/)
-
-### 高级示例
-* [使用 RAG 开发 Q&A 答疑助手](./practices/rag)
-* [具备连续对话能力的聊天机器人](./practices/memory)
-*
diff --git a/src/content/docs/ai/en/overview.md b/src/content/docs/ai/en/overview.md
deleted file mode 100644
index d43d955e3..000000000
--- a/src/content/docs/ai/en/overview.md
+++ /dev/null
@@ -1,29 +0,0 @@
----
-title: Spring AI Alibaba 概述
-keywords: [Spring Cloud Alibaba,Spring AI,Tongyi Qianwen]
-description: "Spring AI 与通义千问集成，使用 Spring AI 开发 Java AI 应用。"
----
-## 什么是 Spring AI Alibaba？
-Spring AI Alibaba 开源项目基于 Spring AI 构建，是阿里云通义系列模型及服务在 Java AI 应用开发领域的最佳实践，提供高层次的 AI API 抽象与云原生基础设施集成方案，帮助开发者快速构建 AI 应用。
-
-<a target="_blank" href="https://img.alicdn.com/imgextra/i1/O1CN01uhDvMY22HZ4q1OZMM_!!6000000007095-2-tps-5440-2928.png"><image src="https://img.alicdn.com/imgextra/i1/O1CN01uhDvMY22HZ4q1OZMM_!!6000000007095-2-tps-5440-2928.png" /></a>
-
-Spring AI Alibaba 作为开发 AI 应用程序的基础框架，定义了以下抽象概念与 API，并提供了 API 与通义系列模型的适配。
-
-* 开发复杂 AI 应用的高阶抽象 Fluent API -- ChatClient
-* 提供多种大模型服务对接能力，包括主流开源与阿里云通义大模型服务（百炼）等
-* 支持的模型类型包括聊天、文生图、音频转录、文生语音等
-* 支持同步和流式 API，在保持应用层 API 不变的情况下支持灵活切换底层模型服务，支持特定模型的定制化能力（参数传递）
-* 支持 Structured Output，即将 AI 模型输出映射到 POJOs
-* 支持矢量数据库存储与检索
-* 支持函数调用 Function Calling
-* 支持构建 AI Agent 所需要的工具调用和对话内存记忆能力
-* 支持 RAG 开发模式，包括离线文档处理如 DocumentReader、Splitter、Embedding、VectorStore 等，支持 Retrieve 检索
-
-以上框架功能可让您实现常见 AI 应用的快速开发，例如 "通过文档进行问答" 或 "通过文档进行聊天" 等。
-
-## Spring AI 项目简介
-
-<a target="_blank" href="https://docs.spring.io/spring-ai/reference/index.html">Spring AI</a> 项目由 Spring 官方开源并维护的 AI 应用开发框架，该项目目标是简化包含人工智能（AI）功能的应用程序的开发，避免不必要的复杂性。该项目从著名的 Python 项目（例如 LangChain 和 LlamaIndex）中汲取灵感，但 Spring AI 并非这些项目的直接移植，该项目的成立基于这样的信念：下一波生成式 AI 应用将不仅面向 Python 开发人员，还将遍及多种编程语言。从本质上讲，Spring AI 解决了 AI 集成的基本挑战：Connecting your enterprise Data and APIs with the AI Models。
-
-
diff --git a/src/content/docs/ai/en/practices/playground-flight-booking.md b/src/content/docs/ai/en/practices/playground-flight-booking.md
deleted file mode 100644
index c910c9636..000000000
--- a/src/content/docs/ai/en/practices/playground-flight-booking.md
+++ /dev/null
@@ -1,105 +0,0 @@
----
-title: 智能机票助手
-keywords: [Spring AI,通义千问,百炼,智能体应用]
-description: "Spring AI 与通义千问集成，使用 Spring AI 开发 Java AI 应用。"
----
-> 本示例项目的源码请参 Github 仓库 [spring-ai-alibaba-examples](https://github.com/alibaba/spring-ai-alibaba/tree/main/spring-ai-alibaba-examples/playground-flight-booking)。
-
-接下来，我们通过一个更贴近实际使用场景的示例，来展示 Spring AI Alibaba 在构建智能体应用方面的强大能力。
-
-示例目标是使用 Spring AI Alibaba 框架开发一个智能机票助手，它可以帮助消费者完成<font style="color:#5e5e5e;">机票预定、问题解答、机票改签、取消等动作，具体要求为：</font>
-
-+ <font style="color:#5e5e5e;">基于 AI 大模型</font>与用户对话，理解用户自然语言表达的需求
-+ <font style="color:#5e5e5e;">支持多轮连续对话，能在上下文中理解用户意图</font>
-+ <font style="color:#5e5e5e;">理解机票操作相关的术语与规范并严格遵守，如航空法规、退改签规则等</font>
-+ 在必要时可<font style="color:#5e5e5e;">调用工具辅助完成任务</font>
-
-#### 完整架构图
-<font style="color:#5e5e5e;">基于这样一个</font>智能机票助手目标，我们绘制了一个如下图所示的架构图：
-
-![](/img/user/ai/practices/flight-booking/architecture.png)
-
-<font style="color:#5e5e5e;">接下来，我们结合架构图对示例进行详细分析。
-</font>
-
-#### <font style="color:#5e5e5e;">为应用接入 AI 模型服务</font>
-<font style="color:#5e5e5e;">本质上来说，我们是要用 Spring Boot 开发一个普通的 Java 应用，这个应用能够持续的接收用户的提问，为用户解决机票相关的问题，之所以叫它为智能体应用是因为我们这个应用可以与 AI 交互，由 AI 帮助应用理解用户问题并为用户做决策，所以对我们机票助手一个简化分解的架构图如下所示：</font>
-
-<font style="color:#5e5e5e;"></font>
-
-![](/img/user/ai/practices/flight-booking/step1-llm.png)
-
-<font style="color:#5e5e5e;"></font>
-
-#### <font style="color:#5e5e5e;">使用 RAG 增加机票退改签规则</font>
-<font style="color:#5e5e5e;">基于以上架构图，应用是由 AI 模型理解用户问题，决策下一步动作、驱动业务流程。但任何一个通用的大模型都能帮我们解决机票相关的问题吗？依赖模型的决策是可靠的吗？比如有用户提出了机票改签的诉求，模型一定是能够很好的理解用户的意图的，这点没有疑问。但它怎么知道当前用户符不符合退票规则那？要知道每个航空公司的改签规则可能都是不一样的；它怎么知道改签手续费的规定那？在这样一个可能带来经济纠纷、法律风险的应用场景下，AI模型必须要知道改签规则的所有细节，并逐条确认用户信息复合规则后，才能最终作出是否改签的决策。</font>
-
-<font style="color:#5e5e5e;">很显然，单纯依赖 AI 模型本身并不能替我们完成上面的要求，这个时候就要用到 RAG（检索增强）模式了。通过 RAG 我们可以把机票退改签相关的领域知识输入给应用和 AI 模型，让 AI 结合这些规则与要求辅助决策，增加 RAG 后的架构如下图所示：</font>
-
-
-![](/img/user/ai/practices/flight-booking/step2-rag.png)
-
-<font style="color:#5e5e5e;"></font>
-
-<font style="color:#5e5e5e;">有了 RAG 之后，我们的应用真正的成为了一个智能化的机票问题专家，就像一个经过公司业务培训的客服代表，既能人性化的与用户对话，又能根据规则引导用户行为。</font>
-
-<font style="color:#5e5e5e;"></font>
-
-#### <font style="color:#5e5e5e;">使用 Function Calling 执行业务动作</font>
-<font style="color:#5e5e5e;">AI 智能体可以帮助应用理解用户需求并作出决策，但是它没法代替应用完成决策的执行，决策的执行还是要由应用自己完成，这一点和传统应用并没有区别，不论是智能化的还是预先编排好的应用，都是要由应用本身去调用函数修改数据库记录实现数据持久化。</font>
-
-<font style="color:#5e5e5e;">通过 Spring AI 框架，我们可以将模型的决策转换为对某个具体函数的调用，从而完成机票的最终改签或者退票动作，将用户数据写入数据库，这就是我们前面提到的 Function Calling 模式。</font>
-
-<font style="color:#5e5e5e;"></font>
-
-![](/img/user/ai/practices/flight-booking/step3-tool.png)
-
-
-#### <font style="color:#5e5e5e;">使用 Chat Memory 增加多轮对话能力</font>
-<font style="color:#5e5e5e;">最后一点是关于多轮连续对话的支持，我们要记住一点，大模型是无状态的，它看到的只有当前这一轮对话的内容。因此如果要支持多轮对话效果，需要应用每次都要把之前的对话上下文保留下来，并与最新的问题一并作为 prompt 发送给模型。这时，我们可以利用 Spring AI Alibaba 提供的内置 Conversation Memory 支持，方便的维护对话上下文。</font>
-
-<font style="color:#5e5e5e;">总结起来，我们在这个智能机票助手应用中用到了 Spring AI Alibaba 的核心如下能力：</font>
-
-1. <font style="color:#5e5e5e;">基本模型对话能力，通过 Chat Model API 与阿里云通义模型交互</font>
-2. <font style="color:#5e5e5e;">Prompt 管理能力</font>
-3. <font style="color:#5e5e5e;">Chat Memory 聊天记忆，支持多轮对话</font>
-4. <font style="color:#5e5e5e;">RAG、Vector Store，机票预定、改签、退票等相关规则</font>
-
-
-![](/img/user/ai/practices/flight-booking/step4-memory.png)
-
-
-#### 使用 ChatClient 完成编码
-Spring AI Alibaba 不止提供了以上原子能力抽象，还提供了高阶 “智能体” API 抽象 `ChatClient`，让我们可以非常方便的使用流式 Fluent API 把多个组件组装起来，成为一个智能体 Agent。`ChatClient` 的使用方式如下：
-
-```java
-this.chatClient = modelBuilder
-				.defaultSystem("""
-						您是“Funnair”航空公司的客户聊天支持代理。请以友好、乐于助人且愉快的方式来回复。
-					   您正在通过在线聊天系统与客户互动。
-					   在提供有关预订或取消预订的信息之前，您必须始终
-					   从用户处获取以下信息：预订号、客户姓名。
-					   在询问用户之前，请检查消息历史记录以获取此信息。
-					   在更改预订之前，您必须确保条款允许这样做。
-					   如果更改需要收费，您必须在继续之前征得用户同意。
-					   使用提供的功能获取预订详细信息、更改预订和取消预订。
-					   如果需要，可以调用相应函数调用完成辅助动作。
-					   请讲中文。
-					   今天的日期是 {current_date}.
-					""")
-				.defaultAdvisors(
-						new PromptChatMemoryAdvisor(chatMemory), // Chat Memory
-						new VectorStoreChatMemoryAdvisor(vectorStore)),
-						new QuestionAnswerAdvisor(vectorStore, SearchRequest.defaults()), // RAG
-						new LoggingAdvisor())
-				.defaultFunctions("getBookingDetails", "changeBooking", "cancelBooking") // FUNCTION CALLING
-
-				.build();
-```
-
-<font style="color:#5e5e5e;">这样，</font>`<font style="color:#5e5e5e;">ChatClient</font>`<font style="color:#5e5e5e;">就为我们屏蔽了所有与大模型交互的细节，只需要把 </font>`<font style="color:#5e5e5e;">ChatClient</font>`<font style="color:#5e5e5e;">注入常规的 Spring Bean 就可以为我们的机票应用加入智能化能力了。</font>
-
-最终，我们开发的示例运行效果如下所示：
-
-![](/img/user/ai/practices/flight-booking/demo.png)
-
diff --git a/src/content/docs/ai/en/practices/rag.md b/src/content/docs/ai/en/practices/rag.md
deleted file mode 100644
index 83ba558ba..000000000
--- a/src/content/docs/ai/en/practices/rag.md
+++ /dev/null
@@ -1,102 +0,0 @@
----
-title: RAG
-keywords: [Spring AI,通义千问,百炼,智能体应用]
-description: "Spring AI 与通义千问集成，使用 Spring AI 开发 Java AI 应用。"
----
-
-## RAG介绍
-检索增强生成 (RAG) 是一种使用来自私有或专有数据源的信息来辅助文本生成的技术。它将检索模型（设计用于搜索大型数据集或知识库）和生成模型（例如大型语言模型 (LLM)，此类模型会使用检索到的信息生成可供阅读的文本回复）结合在一起。
-
-通过从更多数据源添加背景信息，以及通过训练来补充 LLM 的原始知识库，检索增强生成能够提高搜索体验的相关性。这能够改善大型语言模型的输出，但又无需重新训练模型。额外信息源的范围很广，从训练 LLM 时并未用到的互联网上的新信息，到专有商业背景信息，或者属于企业的机密内部文档，都会包含在内。
-
-RAG 对于诸如回答问题和内容生成等任务，具有极大价值，因为它能支持生成式 AI 系统使用外部信息源生成更准确且更符合语境的回答。它会实施搜索检索方法（通常是语义搜索或混合搜索）来回应用户的意图并提供更相关的结果。
-
-下图是一个RAG链路的两个阶段，包括Indexing pipeline阶段和RAG的阶段。
-![img_1.png](/img/user/ai/tutorials/practices/rag_diagram.png)
-
-从上图可以看到, indexing pipeline的阶段主要是将结构化或者非结构化的数据或文档进行加载和解析、chunk切分、文本向量化并保存到向量数据库。
-RAG的阶段主要包括将prompt文本内容转为向量、从向量数据库检索内容、对检索后的文档chunk进行重排和prompt重写、最后调用大模型进行结果的生成。
-
-## RAG调用
-
-### 知识库内容导入
-下边是将pdf文档导入到知识库的代码
-
-```java
-DashScopeApi dashscopeApi = ...;
-
-// 1. 解析文档和chunk切分
-String filePath = "新能源产业有哪些-36氪.pdf";
-DashScopeDocumentCloudReader reader = new DashScopeDocumentCloudReader(filePath, dashscopeApi, null);
-List<Document> documentList = reader.get();
-DashScopeDocumentTransformer transformer = new DashScopeDocumentTransformer(dashscopeApi);
-List<Document> transformerList = transformer.apply(documentList);
-System.out.println(transformerList.size());
-
-// 2. 文档向量化
-DashScopeEmbeddingModel embeddingModel = new DashScopeEmbeddingModel(dashscopeApi);
-Document document = new Document("你好阿里云");
-float[] vectorList = embeddingModel.embed(document);
-
-// 3. 导入文档内容到向量存储
-DashScopeCloudStore cloudStore = new DashScopeCloudStore(dashscopeApi, new DashScopeStoreOptions("bailian-knowledge"));
-cloudStore.add(Arrays.asList(document));
-
-// 4. 删除文档
-cloudStore.delete(Arrays.asList(document.getId()));
-```
-
-### 知识问答
-
-下边代码将根据之前创建的知识库，进行知识问答的代码:
-```java
-DocumentRetriever retriever = new DashScopeDocumentRetriever(dashscopeApi, DashScopeDocumentRetrieverOptions.builder()
-                        .withIndexName("bailian-knowledge")
-                        .build());
-
-ChatClient chatClient = ChatClient.builder(dashscopeChatModel)
-                .defaultAdvisors(new DocumentRetrievalAdvisor(retriever))
-                .build();
-
-ChatResponse response = chatClient
-                .prompt()
-                .user("如何快速开始百炼?")
-                .call()
-                .chatResponse();
-String content = response.getResult().getOutput().getContent();
-Assertions.assertNotNull(content);
-
-logger.info("content: {}", content);
-```
-
-如果需要返回检索召回后，模型采纳和引用的文档内容, 可以通过以下代码实现:
-```java
-DocumentRetriever retriever = new DashScopeDocumentRetriever(dashscopeApi,
-                DashScopeDocumentRetrieverOptions.builder()
-                        .withIndexName("spring-ai知识库")
-                        .build());
-
-ChatClient chatClient = ChatClient.builder(dashscopeChatModel)
-                .defaultAdvisors(new DashScopeDocumentRetrievalAdvisor(retriever, true))
-                .build();
-
-ChatResponse response = chatClient
-                .prompt()
-                .user("如何快速开始百炼?")
-                .call()
-                .chatResponse();
-
-String content = response.getResult().getOutput().getContent();
-Assertions.assertNotNull(content);
-logger.info("content: {}", content);
-
-//获取引用的内容
-List<Document> documents = (List<Document>) response.getMetadata().get(DashScopeDocumentRetrievalAdvisor.RETRIEVED_DOCUMENTS);
-Assertions.assertNotNull(documents);
-
-for (Document document : documents) {
-            logger.info("referenced doc name: {}, title: {}, score: {}", document.getMetadata().get("doc_name"),
-                    document.getMetadata().get("title"), document.getMetadata().get("_score"));
-        }
-
-```
\ No newline at end of file
diff --git a/src/content/docs/ai/en/tutorials/chat-client.md b/src/content/docs/ai/en/tutorials/chat-client.md
deleted file mode 100644
index 636d36413..000000000
--- a/src/content/docs/ai/en/tutorials/chat-client.md
+++ /dev/null
@@ -1,422 +0,0 @@
----
-title: Chat Client
-keywords: [Spring AI,通义千问,百炼,智能体应用]
-description: "Spring AI 与通义千问集成，使用 Spring AI 开发 Java AI 应用。"
----
-
-## ChatClient 简介
-
-`ChatClient` 提供了与 AI 模型通信的 Fluent API，它支持同步和反应式（Reactive）编程模型。与 `ChatModel`、`Message`、`ChatMemory` 等原子 API 相比，使用 `ChatClient` 可以将与 LLM 及其他组件交互的复杂性隐藏在背后，因为基于 LLM 的应用程序通常要多个组件协同工作（例如，提示词模板、聊天记忆、LLM Model、输出解析器、RAG 组件：嵌入模型和存储），并且通常涉及多个交互，因此协调它们会让编码变得繁琐。当然使用 `ChatModel` 等原子 API 可以为应用程序带来更多的灵活性，成本就是您需要编写大量样板代码。
-
-ChatClient 类似于应用程序开发中的服务层，它为应用程序直接提供 `AI 服务`，开发者可以使用 ChatClient Fluent API 快速完成一整套 AI 交互流程的组装。
-
-包括一些基础功能，如：
-* 定制和组装模型的输入（Prompt）
-* 格式化解析模型的输出（Structured Output）
-* 调整模型交互参数（ChatOptions）
-
-还支持更多高级功能：
-* 聊天记忆（Chat Memory）
-* 工具/函数调用（Function Calling）
-* RAG
-
-
-## 创建 ChatClient
-
-使用 `ChatClient.Builder` 对象创建 `ChatClient` 实例，您可以自动注入由Spring Boot 自动配置创建的默认 `ChatClient.Builder` 实例，您也可以通过编程方式自行创建一个 `ChatClient.Builder` 实例并用它来得到 `ChatClient` 实例。
-
-### 使用自动配置的 ChatClient.Builder
-
-在快速开始示例中，就是使用的 Spring Boot 自动装配默认生成的 `ChatClient.Builder` 的 bean，把它注入到您自己的类中。这里是根据用户提问并从模型得到文本回答的简单例子：
-
-```java
-    @RestController
-    public class ChatController {
-
-    	private final ChatClient chatClient;
-
-    	public ChatController(ChatClient.Builder builder) {
-    		this.chatClient = builder.build();
-    	}
-
-    	@GetMapping("/chat")
-    	public String chat(String input) {
-    		return this.chatClient.prompt()
-    				.user(input)
-    				.call()
-    				.content();
-    	}
-    }
-```
-
-在这个示例中，首先设置了用户消息的内容，call 方法向 AI 模型发送请求，content 方法以字符串形式返回 AI 模型的响应。
-
-### 以编程方式创建 ChatClient
-
-您可以通过设置属性 `spring.ai.chat.client.enabled=false` 来禁用 `ChatClient.Builder` bean 的自动配置，如果需要多个聊天模型一起使用，这会很有用，然后以编程方式创建 `ChatClient.Builder`，这样可以为每个聊天模型创建一个实例 `ChatModel`：
-
-```java
-    ChatModel myChatModel = ... // usually autowired
-
-    ChatClient.Builder builder = ChatClient.builder(myChatModel);
-
-    // or create a ChatClient with the default builder settings:
-
-    ChatClient chatClient = ChatClient.create(myChatModel);
-```
-
-## 处理 ChatClient 响应
-
-ChatClient API 提供了多种方法格式化来自 AI 模型的响应。
-
-### 返回 ChatResponse
-
-AI 模型的响应是一种由 [ChatResponse](https://docs.spring.io/spring-ai/reference/api/chatmodel.html#ChatResponse)类型定义的丰富结构。响应类型中包含模型生成的相关元数据信息，同时它还可以包含多个子响应（称为 [Generation](https://docs.spring.io/spring-ai/reference/api/chatmodel.html#Generation)），每个子响应都有自己的元数据。元数据包括用于创建响应的令牌（token）数量信息（在英文中，每个令牌大约为一个单词的 3/4），了解令牌信息很重要，因为 AI 模型根据每个请求使用的令牌数量收费。
-
-下面的代码段显示了通过调用 `chatResponse()` 返回 `ChatResponse` 的示例，相比于调用 `content()` 方法，这里在调用 `call()` 方法之后调用 `chatResponse()`。
-
-```java
-    ChatResponse chatResponse = chatClient.prompt()
-        .user("Tell me a joke")
-        .call()
-        .chatResponse();
-````
-
-### 返回实体类（Entity）
-
-如果您希望应用接口返回一个预先定义好的实体类型（即完成实体 Bean 的映射），Spring AI Alibaba 框架也提供了将模型响应映射到 Java Bean 的转换，您可以在模型的 call() 方法之后调用`entity()` 实现。
-
-例如，给定 Java record（POJO）定义：
-
-```java
-    record ActorFilms(String actor, List<String> movies) {
-    }
-```
-
-您可以使用该 `entity` 方法轻松地将 AI 模型的输出映射到 ActorFilms 类型，如下所示：
-
-```java
-    ActorFilms actorFilms = chatClient.prompt()
-        .user("Generate the filmography for a random actor.")
-        .call()
-        .entity(ActorFilms.class);
-```
-
-`entity` 还有一种带有参数的重载方法 `entity(ParameterizedTypeReference<T> type)`，可让您指定如泛型 List 等类型：
-
-```java
-    List<ActorFilms> actorFilms = chatClient.prompt()
-        .user("Generate the filmography of 5 movies for Tom Hanks and Bill Murray.")
-        .call()
-        .entity(new ParameterizedTypeReference<List<ActorFilms>>() {
-        });
-```
-
-### 流式响应
-
-`stream` 方法是一种异步的、持续获得模型响应的方式：
-
-```java
-    Flux<String> output = chatClient.prompt()
-        .user("Tell me a joke")
-        .stream()
-        .content();
-```
-
-相比于上面的 `Flux<String>`，您还可以使用 `Flux<ChatResponse> chatResponse()` 方法获得 `ChatResponse` 响应数据流。
-
-## call() 返回值
-
-`ChatClient.call()` 方法支持几种不同类型的响应格式。
-
-*   `String content()`：返回响应的字符串内容
-*   `ChatResponse chatResponse()`：返回`ChatResponse`包含多个 Generation 以及有关响应的元数据的对象。例如，使用了多少个令牌来创建响应。
-*   `entity` 返回 Java 类型
-    *   entity(ParameterizedTypeReference<T> type)：用于返回实体类型的集合。
-    *   entity(Class<T> type): 用于返回特定的实体类型。
-    *   entity(StructuredOutputConverter<T> structuredOutputConverter): 用于指定一个实例 `StructuredOutputConverter`，将 `String` 转换为实体类型。
-
-## stream() 返回值
-
-您还可以调用 `stream()` 方法来获得模型的响应，而不是只使用 `call()` 方法，`strem()` 方法的响应类型有以下几种选项：
-
-*   `Flux<String> content()`：返回由 AI 模型生成的 `Flux<String>` 对象。
-*   `Flux<ChatResponse> chatResponse()`：返回 `Flux<ChatResponse>` 对象，其中包含模型相应的元数据和其他信息。
-
-## 自定义 ChatClient 默认值
-
-在前面 ChatClient 的初步体验中，我们使用 `ChatClient.Builder.build()` 快速创建了一个 ChatClient 实例，**开发者还可以使用 `ChatClient.Builder` 来自定义 ChatClient 实例的相关属性**。
-
-注意：**创建 ChatClient 时指定的配置将作为与模型交互时的默认参数，这样可以避免每次调用都重复设置**。
-
-### 设置默认 System Message
-
-在以下示例中，我们为 ChatClient 设置了一个默认的 system message（以海盗风格回答所有问题）。当 ChatClient 与模型交互时都会自动携带这条 system message，用户只需要指定 user message 即可。
-
-```java
-@Configuration
-class Config {
-
-    @Bean
-    ChatClient chatClient(ChatClient.Builder builder) {
-        return builder.defaultSystem("You are a friendly chat bot that answers question in the voice of a Pirate")
-                .build();
-    }
-
-}
-```
-
-在 Controller 中使用自定义的 ChatClient 实例：
-
-```java
-@RestController
-class AIController {
-
-    private final ChatClient chatClient;
-
-    AIController(ChatClient chatClient) {
-        this.chatClient = chatClient;
-    }
-
-    @GetMapping("/ai/simple")
-    public Map<String, String> completion(@RequestParam(value = "message", defaultValue = "Tell me a joke") String message) {
-        return Map.of("completion", chatClient.prompt().user(message).call().content());
-    }
-}
-```
-
-启动示例，通过 curl 测试效果：
-
-```shell
-> curl localhost:8080/ai/simple
-
-{"generation":"Why did the pirate go to the comedy club? To hear some arrr-rated jokes! Arrr, matey!"}
-```
-
-在上面 `builder.defaultSystem()` 创建 ChatClient 时。我们还可以选择使用 Prompt 模板，类似 "You are a friendly chat bot that answers question in the voice of a {voice}"，这让我们有机会在每次调用前修改请求参数。
-
-```java
-@Configuration
-class Config {
-
-    @Bean
-    ChatClient chatClient(ChatClient.Builder builder) {
-        return builder.defaultSystem("You are a friendly chat bot that answers question in the voice of a {voice}")
-                .build();
-    }
-
-}
-
-@RestController
-class AIController {
-    private final ChatClient chatClient
-    AIController(ChatClient chatClient) {
-        this.chatClient = chatClient;
-    }
-    @GetMapping("/ai")
-    Map<String, String> completion(@RequestParam(value = "message", defaultValue = "Tell me a joke") String message, String voice) {
-        return Map.of(
-                "completion",
-                chatClient.prompt()
-                        .system(sp -> sp.param("voice", voice))
-                        .user(message)
-                        .call()
-                        .content());
-    }
-}
-```
-
-答案是：
-
-```shell
-http localhost:8080/ai voice=='Robert DeNiro'
-
-{
-    "completion": "You talkin' to me? Okay, here's a joke for ya: Why couldn't the bicycle stand up by itself? Because it was two tired! Classic, right?"
-}
-```
-
-### 其他默认设置
-
-除了 `defaultSystem` 之外，您还可以在 `ChatClient.Builder` 中指定其他默认提示词。
-
-*   `defaultOptions(ChatOptions chatOptions)`：传入 `ChatOptions` 类中定义的可移植选项或特定于模型实现的如 `DashScopeChatOptions` 选项。有关特定于模型的`ChatOptions`实现的更多信息，请参阅 JavaDocs。
-
-*   `defaultFunction(String name, String description, java.util.function.Function<I, O> function)`：`name` 用于在用户文本中引用该函数，`description`解释该函数的用途并帮助 AI 模型选择正确的函数以获得准确的响应，参数 `function` 是模型将在必要时执行的 Java 函数实例。
-
-*   `defaultFunctions(String... functionNames)`：应用程序上下文中定义的 java.util.Function 的 bean 名称。
-
-*   `defaultUser(String text)`、`defaultUser(Resource text)`、`defaultUser(Consumer<UserSpec> userSpecConsumer)` 这些方法允许您定义用户消息输入，`Consumer<UserSpec>`允许您使用 lambda 指定用户消息输入和任何默认参数。
-
-*   `defaultAdvisors(RequestResponseAdvisor... advisor)`：Advisors 允许修改用于创建 `Prompt` 的数据，`QuestionAnswerAdvisor` 实现通过在 Prompt 中附加与用户文本相关的上下文信息来实现 `Retrieval Augmented Generation` 模式。
-
-*   `defaultAdvisors(Consumer<AdvisorSpec> advisorSpecConsumer)`：此方法允许您定义一个 `Consumer` 并使用 `AdvisorSpec` 配置多个 Advisor，Advisor 可以修改用于创建 `Prompt` 的最终数据，`Consumer<AdvisorSpec>` 允许您指定 lambda 来添加 Advisor 例如 `QuestionAnswerAdvisor`。
-
-您可以在运行时使用 `ChatClient` 提供的不带 `default` 前缀的相应方法覆盖这些默认值。
-
-*   `options(ChatOptions chatOptions)`
-
-*   `function(String name, String description, java.util.function.Function<I, O> function)`
-
-*   `functions(String... functionNames)`
-
-*   `user(String text)`、`user(Resource text)`、`user(Consumer<UserSpec> userSpecConsumer)`
-
-*   `advisors(RequestResponseAdvisor... advisor)`
-
-*   `advisors(Consumer<AdvisorSpec> advisorSpecConsumer)`
-
-
-## Advisors
-
-在使用用户输入文本构建 Prompt 调用 AI 模型时。一个常见模式是使用上下文数据附加或扩充 Prompt，最终使用扩充后的 Prompt 与模型交互。
-
-这些用于扩充 Prompt 的上下文数据可以是不同类型的，常见类型包括：
-
-* **您自己的数据**：这是 AI 模型尚未训练过的数据，如特定领域知识、产品文档等，即使模型已经看到过类似的数据，附加的上下文数据也会优先生成响应。
-* **对话历史记录**：聊天模型的 API 是无状态的，如果您告诉 AI 模型您的姓名，它不会在后续交互中记住它，每次请求都必须发送对话历史记录，以确保在生成响应时考虑到先前的交互。
-
-### 检索增强生成（RAG）
-
-向量数据库存储的是 AI 模型不知道的数据，当用户问题被发送到 AI 模型时，`QuestionAnswerAdvisor`  会在向量数据库中查询与用户问题相关的文档。
-
-来自向量数据库的响应被附加到用户消息 Prompt 中，为 AI 模型生成响应提供上下文。
-
-假设您已将数据加载到中 `VectorStore`，则可以通过向 `ChatClient` 提供 `QuestionAnswerAdvisor` 实例来执行检索增强生成 (RAG ) 。
-
-```java
-ChatResponse response = ChatClient.builder(chatModel)
-        .build().prompt()
-        .advisors(new QuestionAnswerAdvisor(vectorStore, SearchRequest.defaults()))
-        .user(userText)
-        .call()
-        .chatResponse();
-```
-
-在此示例中，`SearchRequest.defaults()` 将对 Vector 向量数据库中的所有文档执行相似性搜索。为了限制要搜索的文档类型，`SearchRequest` 采用了可移植到任意向量数据库中的类似 SQL 筛选表达式。
-
-#### 动态过滤表达式
-
-`SearchRequest` 使用 `FILTER_EXPRESSION` Advisor 上下文参数在运行时更新过滤表达式：
-
-```java
-ChatClient chatClient = ChatClient.builder(chatModel)
-    .defaultAdvisors(new QuestionAnswerAdvisor(vectorStore, SearchRequest.defaults()))
-    .build();
-
-// Update filter expression at runtime
-String content = chatClient.prompt()
-    .user("Please answer my question XYZ")
-    .advisors(a -> a.param(QuestionAnswerAdvisor.FILTER_EXPRESSION, "type == 'Spring'"))
-    .call()
-    .content();
-```
-
-该 `FILTER_EXPRESSION` 参数允许您根据提供的表达式动态过滤搜索结果。
-
-### 聊天记忆
-
-`ChatMemory` 接口表示聊天对话历史记录的存储，它提供向对话添加消息、从对话中检索消息以及清除对话历史记录的方法。
-
-目前提供两种实现方式 `InMemoryChatMemory`、`CassandraChatMemory`，分别为聊天对话历史记录提供内存存储和 `time-to-live` 类型的持久存储。
-
-创建一个包含 `time-to-live` 配置的 `CassandraChatMemory`
-
-```java
-    CassandraChatMemory.create(CassandraChatMemoryConfig.builder().withTimeToLive(Duration.ofDays(1)).build());
-```
-
-以下 Advisor 实现使用 `ChatMemory` 接口来使用对话历史记录来增强（advice）Prompt，这些 advisor 实现在如何将对话历史记录添加到 Prompt 的细节上有所不同。
-
-*   `MessageChatMemoryAdvisor`：内存被检索并作为消息集合添加到提示中
-*   `PromptChatMemoryAdvisor`：检索内存并将其添加到提示的系统文本中。
-*   `VectorStoreChatMemoryAdvisor` ：构造函数`VectorStoreChatMemoryAdvisor(VectorStore vectorStore, String defaultConversationId, int chatHistoryWindowSize)`允许您指定要从中检索聊天历史记录的 VectorStore、唯一的对话 ID、要检索的聊天历史记录的大小（以令牌大小为单位）。
-
-
-下面的 `@Service` 提供了一个使用多个 Advisor 的示例实现：
-
-```java
-import static org.springframework.ai.chat.client.advisor.AbstractChatMemoryAdvisor.CHAT_MEMORY_CONVERSATION_ID_KEY;
-import static org.springframework.ai.chat.client.advisor.AbstractChatMemoryAdvisor.CHAT_MEMORY_RETRIEVE_SIZE_KEY;
-
-@Service
-public class CustomerSupportAssistant {
-
-    private final ChatClient chatClient;
-
-    public CustomerSupportAssistant(ChatClient.Builder builder, VectorStore vectorStore, ChatMemory chatMemory) {
-
-    this.chatClient = builder
-            .defaultSystem("""
-                    You are a customer chat support agent of an airline named "Funnair".", Respond in a friendly,
-                    helpful, and joyful manner.
-
-                    Before providing information about a booking or cancelling a booking, you MUST always
-                    get the following information from the user: booking number, customer first name and last name.
-
-                    Before changing a booking you MUST ensure it is permitted by the terms.
-
-                    If there is a charge for the change, you MUST ask the user to consent before proceeding.
-                    """)
-            .defaultAdvisors(
-                    new PromptChatMemoryAdvisor(chatMemory),
-                    // new MessageChatMemoryAdvisor(chatMemory), // CHAT MEMORY
-                    new QuestionAnswerAdvisor(vectorStore, SearchRequest.defaults()),
-                    new LoggingAdvisor()) // RAG
-            .defaultFunctions("getBookingDetails", "changeBooking", "cancelBooking") // FUNCTION CALLING
-            .build();
-}
-
-public Flux<String> chat(String chatId, String userMessageContent) {
-
-    return this.chatClient.prompt()
-            .user(userMessageContent)
-            .advisors(a -> a
-                    .param(CHAT_MEMORY_CONVERSATION_ID_KEY, chatId)
-                    .param(CHAT_MEMORY_RETRIEVE_SIZE_KEY, 100))
-            .stream().content();
-    }
-}
-```
-
-### 日志记录
-
- `SimpleLoggerAdvisor` 是一个用于记录 ChatClient 的 `request` 和 `response` 数据 Advisor，这对于调试和监控您的 AI 交互非常有用。
-
-要启用日志记录，请在创建 ChatClient 时将 `SimpleLoggerAdvisor` 添加到 Advisor 链中。建议将其添加到链的末尾：
-
-```java
-ChatResponse response = ChatClient.create(chatModel).prompt()
-        .advisors(new SimpleLoggerAdvisor())
-        .user("Tell me a joke?")
-        .call()
-        .chatResponse();
-```
-
-要查看日志，请将 Advisor 包的日志记录级别设置为 `DEBUG`：
-
-```properties
-org.springframework.ai.chat.client.advisor=DEBUG
-```
-
-将其添加到您的 `application.properties` 或 `application.yaml` 文件中。
-
-您可以使用以下构造函数自定义如何使用 `SimpleLoggerAdvisor` 记录来自 AdvisedRequest 和 ChatResponse 的数据：
-
-```java
-SimpleLoggerAdvisor(
-    Function<AdvisedRequest, String> requestToString,
-    Function<ChatResponse, String> responseToString
-)
-```
-
-使用示例：
-
-```java
-javaCopySimpleLoggerAdvisor customLogger = new SimpleLoggerAdvisor(
-    request -> "Custom request: " + request.userText,
-    response -> "Custom response: " + response.getResult()
-);
-```
-
-这使得您可以根据您的特定需求定制需要记录的信息。
diff --git a/src/content/docs/ai/en/tutorials/chat-model.md b/src/content/docs/ai/en/tutorials/chat-model.md
deleted file mode 100644
index c0f324ee4..000000000
--- a/src/content/docs/ai/en/tutorials/chat-model.md
+++ /dev/null
@@ -1,98 +0,0 @@
----
-title: 对话模型(Chat Model)
-keywords: [Spring AI,通义千问,百炼,智能体应用]
-description: "Spring AI 与通义千问集成，使用 Spring AI 开发 Java AI 应用。"
----
-
-对话模型（Chat Model）接收一系列消息（Message）作为输入，与模型 LLM 服务进行交互，并接收返回的聊天消息（Chat Message）作为输出。相比于普通的程序输入，模型的输入与输出消息（Message）不止支持纯字符文本，还支持包括语音、图片、视频等作为输入输出。同时，在 Spring AI Alibaba 中，消息中还支持包含不同的角色，帮助底层模型区分来自模型、用户和系统指令等的不同消息。
-
-Spring AI Alibaba 复用了 Spring AI 抽象的 Model API，并与通义系列大模型服务进行适配（如通义千问、通义万相等），目前支持纯文本聊天、文生图、文生语音、语音转文本等。以下是框架定义的几个核心 API：
-* ChatModel，文本聊天交互模型，支持纯文本格式作为输入，并将模型的输出以格式化文本形式返回。
-* ImageModel，接收用户文本输入，并将模型生成的图片作为输出返回。
-* AudioModel，接收用户文本输入，并将模型合成的语音作为输出返回。
-
-Spring AI Alibaba 支持以上 Model 抽象与通义系列模型的适配，并通过 `spring-ai-alibaba-starter` AutoConfiguration 自动初始化了默认实例，因此我们可以在应用程序中直接注入 ChatModel、ImageModel 等 bean，当然在需要的时候也可以自定义 Model 实例。
-
-## Chat Model
-
-ChatModel API 让应用开发者可以非常方便的与 AI 模型进行文本交互，它抽象了应用与模型交互的过程，包括使用 `Prompt` 作为输入，使用 `ChatResponse` 作为输出等。ChatModel 的工作原理是接收 Prompt 或部分对话作为输入，将输入发送给后端大模型，模型根据其训练数据和对自然语言的理解生成对话响应，应用程序可以将响应呈现给用户或用于进一步处理。
-
-![chat-model](https://img.alicdn.com/imgextra/i2/O1CN01wyTDFO1kR2BJOn3fe_!!6000000004679-0-tps-2555-1565.jpg)
-
-### 使用示例
-开发完整的 ChatModel 示例应用，您需要添加 `spring-ai-alibaba-starter` 依赖，请参考快速开始中的项目配置说明了解详情，您还可以访问 [chatmodel-example](https://github.com/alibaba/spring-ai-alibaba/tree/main/spring-ai-alibaba-examples/chatmodel-example) 查看本示例完整源码。
-
-以下是 ChatModel 基本使用示例，它可以接收 String 字符串作为输入：
-
-```java
-@RestController
-public class ChatModelController {
-	private final ChatModel chatModel;
-
-	public ChatModelController(ChatModel chatModel) {
-		this.chatModel = chatModel;
-	}
-
-	@RequestMapping("/chat")
-	public String chat(String input) {
-		ChatResponse response = chatModel.call(new Prompt(input));
-		return response.getResult().getOutput().getContent();
-	}
-}
-```
-
-使用 Prompt 作为输入：
-```java
-
-```
-
-Streaming 示例：
-```java
-
-```
-
-通过 ChatOptions 在每次调用中调整模型参数：
-```java
-
-```
-
-## Image Model
-ImageModel API 抽象了应用程序通过模型调用实现“文生图”的交互过程，即应用程序接收文本，调用模型生成图片。ImageModel 的入参为包装类型 `ImagePrompt`，输出类型为 `ImageResponse`。
-
-### 使用示例
-
-`spring-ai-alibaba-starter` AutoConfiguration 默认初始化了 ImageModel 实例，我们可以选择直接注入并使用默认实例。
-
-```java
-@RestController
-public class ImageModelController {
-	private final ImageModel imageModel;
-
-	ImageModelController(ImageModel imageModel) {
-		this.imageModel = imageModel;
-	}
-
-	@RequestMapping("/image")
-	public String image(String input) {
-		ImageOptions options = ImageOptionsBuilder.builder()
-				.withModel("dall-e-3")
-				.build();
-
-		ImagePrompt imagePrompt = new ImagePrompt(input, options);
-		ImageResponse response = imageModel.call(imagePrompt);
-		String imageUrl = response.getResult().getOutput().getUrl();
-
-		return "redirect:" + imageUrl;
-	}
-}
-```
-
-通过 ImageOptions 在每次调用中调整模型参数：
-```java
-
-```
-
-## Audio Model
-当前，Spring AI Alibaba 支持以下两种通义语音模型的适配，分别是：
-1. 文本生成语音 SpeechModel，对应于 OpenAI 的 Text-To-Speech (TTS) API
-2. 录音文件生成文字 DashScopeAudioTranscriptionModel，对应于 OpenAI 的 Transcription API
diff --git a/src/content/docs/ai/en/tutorials/embedding.md b/src/content/docs/ai/en/tutorials/embedding.md
deleted file mode 100644
index 84bd71a0d..000000000
--- a/src/content/docs/ai/en/tutorials/embedding.md
+++ /dev/null
@@ -1,187 +0,0 @@
----
-title: 嵌入模型 (Embedding Model)
-keywords: [Spring AI,通义千问,百炼,智能体应用]
-description: "Spring AI 与通义千问集成，使用 Spring AI 开发 Java AI 应用。"
----
-
-## 核心概念
-嵌入(`Embedding`)的工作原理是将文本、图像和视频转换为称为向量（Vectors）的浮点数数组。这些向量旨在捕捉文本、图像和视频的含义。嵌入数组的长度称为向量的维度（Dimensionality）。
-
-嵌入模型（`EmbeddingModel`）是嵌入过程中采用的模型。当前EmbeddingModel的接口主要用于将文本转换为数值向量，接口的设计主要围绕这两个目标展开：
-- 可移植性：该接口确保在各种嵌入模型之间的轻松适配。它允许开发者在不同的嵌入技术或模型之间切换，所需的代码更改最小化。这一设计与 Spring 模块化和互换性的理念一致。 
-- 简单性：嵌入模型简化了文本转换为嵌入的过程。通过提供如`embed(String text)`和`embed(Document document)`这样简单的方法，它去除了处理原始文本数据和嵌入算法的复杂性。这个设计选择使开发者，尤其是那些初次接触 AI 的开发者，更容易在他们的应用程序中使用嵌入，而无需深入了解其底层机制。
-
-## API介绍
-### EmbeddingModel
-本节介绍`EmbeddingModel`的接口和类。
-```java
-public interface EmbeddingModel extends Model<EmbeddingRequest, EmbeddingResponse> {
-
-    @Override
-    EmbeddingResponse call(EmbeddingRequest request);
-
-    /**
-     * Embeds the given document's content into a vector.
-     * @param document the document to embed.
-     * @return the embedded vector.
-     */
-    List<Double> embed(Document document);
-
-    /**
-     * Embeds the given text into a vector.
-     * @param text the text to embed.
-     * @return the embedded vector.
-     */
-    default List<Double> embed(String text) {
-        Assert.notNull(text, "Text must not be null");
-        return this.embed(List.of(text)).iterator().next();
-    }
-
-    /**
-     * Embeds a batch of texts into vectors.
-     * @param texts list of texts to embed.
-     * @return list of list of embedded vectors.
-     */
-    default List<List<Double>> embed(List<String> texts) {
-        Assert.notNull(texts, "Texts must not be null");
-        return this.call(new EmbeddingRequest(texts, EmbeddingOptions.EMPTY))
-                .getResults()
-                .stream()
-                .map(Embedding::getOutput)
-                .toList();
-    }
-
-    /**
-     * Embeds a batch of texts into vectors and returns the {@link EmbeddingResponse}.
-     * @param texts list of texts to embed.
-     * @return the embedding response.
-     */
-    default EmbeddingResponse embedForResponse(List<String> texts) {
-        Assert.notNull(texts, "Texts must not be null");
-        return this.call(new EmbeddingRequest(texts, EmbeddingOptions.EMPTY));
-    }
-
-    /**
-     * @return the number of dimensions of the embedded vectors. It is generative
-     * specific.
-     */
-    default int dimensions() {
-        return embed("Test String").size();
-    }
-
-}
-```
-Embedding Model API提供多种选项，将文本转换为Embeddings，支持单个字符串、结构化的Document对象或文本批处理。
-
-有多种快捷方式可以获得文本Embeddings。例如`embed(String text)`方法，它接受单个字符串并返回相应的 Embedding 向量。所有方法都围绕着`call`方法实现，这是调用 Embedding Model的主要方法。
-
-通常，Embedding返回一个float数组，以数值向量格式表示Embeddings。
-
-`embedForResponse`方法提供了更全面的输出，可能包括有关Embeddings的其他信息。
-
-`dimensions`方法是开发人员快速确定 Embedding 向量大小的便利工具，这对于理解 Embedding space 和后续处理步骤非常重要。
-#### EmbeddingRequest
-`EmbeddingRequest`是一种`ModelRequest`，它接受文本对象列表和可选的Embedding请求选项。以下代码片段简要地显示了 EmbeddingRequest 类，省略了构造函数和其他工具方法：
-```java
-public class EmbeddingRequest implements ModelRequest<List<String>> {
-private final List<String> inputs;
-private final EmbeddingOptions options;
-// other methods omitted
-}
-```
-
-#### EmbeddingResponse
-`EmbeddingResponse`类的结构如下：
-```java
-public class EmbeddingResponse implements ModelResponse<Embedding> {
-    private List<Embedding> embeddings;
-    private EmbeddingResponseMetadata metadata = new EmbeddingResponseMetadata();
-    // other methods omitted
-}
-```
-`EmbeddingResponse`类保存了AI模型的输出，其中每个 Embedding 实例包含来自单个文本输入的结果向量数据。同时，它还携带了有关 AI 模型响应的`EmbeddingResponseMetadata`元数据。
-#### Embedding
-`Embedding`表示一个 Embedding 向量。
-```java
-public class Embedding implements ModelResult<List<Double>> {
-    private List<Double> embedding;
-    private Integer index;
-    private EmbeddingResultMetadata metadata;
-// other methods omitted
-}
-```
-## 示例用法
-Spring AI Alibaba已经集成了`阿里云百炼平台`，接下来介绍基于阿里云百炼平台调用Embedding Model API。
-### 准备工作
-在开始之前，参考如下链接获取API-KEY：[获取API-KEY](https://help.aliyun.com/zh/model-studio/developer-reference/get-api-key)。
-然后，在项目环境中设置API-KEY，有两种方式：
-
-- 方式一：设置`configuration properties：spring.ai.dashscope.api-key` 为上述API-KEY。
-- 方式二：设置环境变量`export SPRING_AI_DASHSCOPE_API_KEY=<YOUR API  KEY>`
-
-### Auto-configuration
-Spring AI 为 DashScope Embedding Model提供了 Spring Boot 的自动配置。要启用此功能，请将以下依赖项添加到您项目的 Maven`pom.xml`文件中：
-```xml
-<dependency>
-    <groupId>com.alibaba.cloud.ai</groupId>
-    <artifactId>spring-ai-alibaba-starter</artifactId>
-    <version>1.0.0-M2.1</version>
-</dependency>
-```
-或者添加到您的Gradle`build.gradle`文件中：
-```gradle
-dependencies {
-    implementation 'com.alibaba.cloud.ai:spring-ai-alibaba-starter:1.0.0-M2.1'
-}
-```
-#### Embedding Properties
-前缀`spring.ai.dashscope`是用于配置连接至 DashScope 的属性前缀。
-
-| Property                       | Action          | Default |
-|:-------------------------------|:----------------|---------|
-| `spring.ai.dashscope.api-key`  | 来自百炼平台的API KEY  | -       |
-
-
-```tips
-所有以 spring.ai.dashscope 开头的属性都可以在运行过程中通过在 EmbeddingRequest 调用中添加特定请求的Runtime Options来覆盖。
-```
-
-### Runtime Options
-`DashScopeEmbeddingOptions`提供了Embedding Request的配置信息，它提供了一个构建器，用于创建选项。
-
-在启动时，可以使用`DashScopeEmbeddingModel`构造函数设置所有嵌入请求使用的默认选项。在运行时，可以通过将一个`DashScopeEmbeddingOptions`实例传递给`EmbeddingRequest`请求来覆盖默认选项。
-
-例如，使用指定的请求覆盖默认的模型名称：
-```java
-EmbeddingResponse embeddingResponse = embeddingModel.call(
-        new EmbeddingRequest(List.of("Hello World", "World is big and salvation is near"),
-                DashScopeEmbeddingOptions.builder()
-                        .withModel("Different-Embedding-Model-Deployment-Name")
-                        .build()));
-```
-
-### 示例代码
-该示例将创建一个`EmbeddingModel`实例，您可以将其注入到您的类中。以下是一个简单的`@Controller`类的示例，它使用了该 EmbeddingModel 实例。
-```properties
-spring.ai.dashscope.api-key=YOUR_API_KEY
-```
-
-```java
-@RestController
-public class EmbeddingController {
-
-    private final EmbeddingModel embeddingModel;
-
-    @Autowired
-    public EmbeddingController(EmbeddingModel embeddingModel) {
-        this.embeddingModel = embeddingModel;
-    }
-
-    @GetMapping("/ai/embedding")
-    public Map embed(@RequestParam(value = "message", defaultValue = "Tell me a joke") String message) {
-        EmbeddingResponse embeddingResponse = this.embeddingModel.embedForResponse(List.of(message));
-        return Map.of("embedding", embeddingResponse);
-    }
-}
-```
-
diff --git a/src/content/docs/ai/en/tutorials/function-calling.md b/src/content/docs/ai/en/tutorials/function-calling.md
deleted file mode 100644
index 6538b99ff..000000000
--- a/src/content/docs/ai/en/tutorials/function-calling.md
+++ /dev/null
@@ -1,255 +0,0 @@
----
-title: 工具(Function Calling)
-keywords: [Spring AI,通义千问,百炼,智能体应用]
-description: "Spring AI 与通义千问集成，使用 Spring AI 开发 Java AI 应用。"
----
-
-“工具（Tool）”或“功能调用（Function Calling）”允许大型语言模型（LLM）在必要时调用一个或多个可用的工具，这些工具通常由开发者定义。工具可以是任何东西：网页搜索、对外部 API 的调用，或特定代码的执行等。LLM 本身不能实际调用工具；相反，它们会在响应中表达调用特定工具的意图（而不是以纯文本回应）。然后，我们应用程序应该执行这个工具，并报告工具执行的结果给模型。
-
-例如，我们知道 LLM 自身在数学方面不是特别擅长。如果你的用例偶尔涉及数学计算，你可能会想提供给 LLM 一个“数学工具”。通过在请求中声明一个或多个工具，LLM 可以在认为合适时调用其中之一。给定一个数学问题和一组数学工具，LLM 可能会决定为正确回答问题，它应该首先调用其中一个提供的数学工具。
-
-接下来，让我们用一个示例看一下 Function Calling 的具体工作过程。
-
-以下是没有 Function Calling 的一个消息交互过程示例，模型给给出的结果非常接近但是并不正确：
-
-```text
-Request:
-- messages:
-    - UserMessage:
-        - text: What is the square root of 475695037565?
-
-Response:
-- AiMessage:
-    - text: The square root of 475695037565 is approximately 689710.
-```
-
-以下是包含了 Function Calling 的消息交互过程：
-
-```text
-Request 1:
-- messages:
-    - UserMessage:
-        - text: What is the square root of 475695037565?
-- tools:
-    - sum(double a, double b): Sums 2 given numbers
-    - squareRoot(double x): Returns a square root of a given number
-
-Response 1:
-- AiMessage:
-    - toolExecutionRequests:
-        - squareRoot(475695037565)
-
-
-... here we are executing the squareRoot method with the "475695037565" argument and getting "689706.486532" as a result ...
-
-
-Request 2:
-- messages:
-    - UserMessage:
-        - text: What is the square root of 475695037565?
-    - AiMessage:
-        - toolExecutionRequests:
-            - squareRoot(475695037565)
-    - ToolExecutionResultMessage:
-        - text: 689706.486532
-
-Response 2:
-- AiMessage:
-    - text: The square root of 475695037565 is 689706.486532.
-```
-
-其中，函数定义如下：
-```java
-@Bean
-@Description("Get the weather in location") // function description
-public Function<MockWeatherService.Request, MockWeatherService.Response> weatherFunction1() {
-	return new MockWeatherService();
-}
-```
-
-正如你所看到的，当 LLM 可以访问工具时，它可以在合适的情况下决定调用其中一个工具，这是一个非常强大的功能。在这个简单的示例中，我们给 LLM 提供了基本的数学工具，但想象一下，如果我们给它提供了，比如说，googleSearch 和 sendEmail 工具，并且有一个查询像是“我的朋友想了解 AI 领域的最新新闻。将简短的总结发送到 friend@email.com”，那么它可以使用 googleSearch 工具查找最新新闻，然后总结这些信息并通过 sendEmail 工具将总结发送到指定的邮箱。
-
-## API 概览
-
-通常，自定义函数需要提供一个 `name`、`description` 和 `function call signature`，以便模型知道函数能做什么、期望的输入参数。
-
-Spring AI 使这一过程变得简单，只需定义一个返回 `java.util.Function` 的 @Bean 定义，并在调用 ChatModel 时将 bean 名称作为选项进行注册。在底层，Spring 会用适当的适配器代码包装你的 POJO（即函数），以便与 AI 模型进行交互，免去了编写繁琐的样板代码。`FunctionCallback.java`  接口和配套的 `FunctionCallbackWrapper.java` 工具类包含了底层实现代码，它们是简化 Java 回调函数的实现和注册的关键。
-
-![function calling flow](https://img.alicdn.com/imgextra/i1/O1CN01CfzrO11PzHs9GTPKG_!!6000000001911-0-tps-2372-1685.jpg)
-
-## 使用示例
-在以下示例中，我们将创建一个聊天机器人，通过调用我们自己的函数来回答问题。为了支持聊天机器人的响应，我们将注册一个自己的函数，该函数接受一个位置并返回该位置的当前天气。当模型需要回答诸如 “What’s the weather like in Boston?” 这样的问题时，AI 模型将调用客户端，将位置值作为参数传递给函数。这种类似 RPC 的数据将以 JSON 格式传递。
-
-我们的函数调用某个基于 SaaS 的天气服务 API，并将天气响应返回给模型以完成对话。在这个示例中，我们将使用一个名为 MockWeatherService 的简单实现，它为不同位置硬编码了温度。
-
-> 示例源码请参见 [function-calling-example](https://github.com/alibaba/spring-ai-alibaba/tree/main/spring-ai-alibaba-examples/function-calling-example)
-
-以下是代表天气服务 API 的 MockWeatherService.java：
-
-```java
-public class MockWeatherService implements Function<Request, Response> {
-	public enum Unit { C, F }
-	public record Request(String location, Unit unit) {}
-	public record Response(double temp, Unit unit) {}
-
-	public Response apply(Request request) {
-		return new Response(30.0, Unit.C);
-	}
-}
-```
-
-### 定义&注册函数
-
-通过这种方法，您可以在应用程序上下文中定义 @Beans，就像定义任何其他 Spring 管理对象一样。
-
-在内部，Spring AI ChatModel 将创建一个 FunctionCallbackWrapper 包装器的实例，该包装器添加通过 AI 模型调用它的逻辑。@Bean 的名称作为 ChatOption 传递。
-
-```java
-@Configuration
-static class Config {
-	@Bean
-	@Description("Get the weather in location") // function description
-	public Function<MockWeatherService.Request, MockWeatherService.Response> weatherFunction1() {
-		return new MockWeatherService();
-	}
-	...
-}
-```
-
-@Description 注释是可选的，它提供了函数描述 (2)，可帮助模型了解何时调用该函数。这是一个重要的属性，可帮助 AI 模型确定要调用哪个客户端函数。
-
-提供函数描述的另一种选择是使用 MockWeatherService.Request 上的 @JsonClassDescription 注释来提供函数描述：
-
-```java
-@Configuration
-static class Config {
-	@Bean
-	public Function<Request, Response> currentWeather3() { // (1) bean name as function name.
-		return new MockWeatherService();
-	}
-	...
-}
-
-@JsonClassDescription("Get the weather in location") // (2) function description
-public record Request(String location, Unit unit) {}
-```
-
-最佳做法是使用信息注释请求对象，以便该函数生成的 JSON 模式尽可能具有描述性，以帮助 AI 模型选择要调用的正确函数。
-
-如果已经有定义的@Service，那么可以通过以下方式来通过function call来调用已有的service的方法。
-```java
-// 1. 已存在的MockOrderService
-@Service
-public class MockOrderService {
-    public Response getOrder(Request request) {
-        String productName = "尤尼克斯羽毛球拍";
-        return new Response(String.format("%s的订单编号为%s, 购买的商品为: %s", request.userId, request.orderId, productName));
-    }
-
-    @JsonInclude(JsonInclude.Include.NON_NULL)
-    public record Request(
-            //这里的JsonProperty将转换为function的parameters信息, 包括参数名称和参数描述等
-            /*
-             {
-                "orderId": {
-                    "type": "string",
-                    "description": "订单编号, 比如1001***"
-                    },
-                "userId": {
-                    "type": "string",
-                    "description": "用户编号, 比如2001***"
-                }
-            }
-            */
-            @JsonProperty(required = true, value = "orderId") @JsonPropertyDescription("订单编号, 比如1001***") String orderId,
-            @JsonProperty(required = true, value = "userId") @JsonPropertyDescription("用户编号, 比如2001***") String userId) {
-    }
-
-    public record Response(String description) {
-    }
-}
-
-//2. 将MockOrderService的getOrder注册为function call的bean
-@Configuration
-public class FunctionCallConfiguration {
-    @Bean
-    @Description("根据用户编号和订单编号查询订单信息")  //function的描述
-    public Function<MockOrderService.Request, MockOrderService.Response> getOrderFunction(MockOrderService mockOrderService) {
-        return mockOrderService::getOrder;
-    }
-}
-
-//3. 调用function call
-DashScopeChatModel dashscopeChatModel = ...;
-ChatClient chatClient = ChatClient.builder(dashscopeChatModel)
-        .defaultFunctions("getOrderFunction")
-        .build();
-
-ChatResponse response = chatClient
-        .prompt()
-        .user("帮我一下订单, 用户编号为1001, 订单编号为2001")
-        .call()
-        .chatResponse();
-
-String content = response.getResult().getOutput().getContent();
-logger.info("content: {}", content);
-
-```
-
-> 还有一种函数注册方式是使用 `FunctionCallbackWrapper`，具体请查看示例仓库中的源码。
-
-### 为 Prompt 指定函数
-为了让模型知道并调用您的 CurrentWeather 函数，您需要在 Prompt 请求中启用它。
-
-#### ChatClient
-
-```java
-	ChatResponse response = chatClient.prompt()
-		.functions("CurrentWeather")
-		.user("What's the weather like in San Francisco, Tokyo, and Paris?")
-		.call()
-		.chatResponse();
-```
-
-#### ChatModel
-
-```java
-OpenAiChatModel chatModel = ...
-
-UserMessage userMessage = new UserMessage("What's the weather like in San Francisco, Tokyo, and Paris?");
-
-ChatResponse response = chatModel.call(new Prompt(List.of(userMessage),
-		OpenAiChatOptions.builder().withFunction("CurrentWeather").build())); // (1) Enable the function
-
-logger.info("Response: {}", response);
-```
-
-上述用户问题将触发 3 次对 CurrentWeather 函数的调用（每个城市一次），最终的响应将是这样的：
-
-```text
-Here is the current weather for the requested cities:
-- San Francisco, CA: 30.0°C
-- Tokyo, Japan: 10.0°C
-- Paris, France: 15.0°C
-```
-
-### 动态注册函数
-
-除了自动配置之外，您还可以使用 Prompt 请求动态注册回调函数：
-
-```java
-OpenAiChatModel chatModel = ...
-
-UserMessage userMessage = new UserMessage("What's the weather like in San Francisco, Tokyo, and Paris?");
-
-var promptOptions = OpenAiChatOptions.builder()
-	.withFunctionCallbacks(List.of(new FunctionCallbackWrapper<>(
-		"CurrentWeather", // name
-		"Get the weather in location", // function description
-		new MockWeatherService()))) // function code
-	.build();
-
-ChatResponse response = chatModel.call(new Prompt(List.of(userMessage), promptOptions));
-```
-
-这种方法允许根据用户输入动态选择要调用的不同函数，无需预先声明函数为 bean 实例。
diff --git a/src/content/docs/ai/en/tutorials/memory.md b/src/content/docs/ai/en/tutorials/memory.md
deleted file mode 100644
index aae7d07c4..000000000
--- a/src/content/docs/ai/en/tutorials/memory.md
+++ /dev/null
@@ -1,85 +0,0 @@
----
-title: 对话记忆
-keywords: [Spring AI,通义千问,百炼,智能体应用]
-description: "Spring AI 与通义千问集成，使用 Spring AI 开发 Java AI 应用。"
----
-
-## 对话记忆介绍
-
-"大模型的对话记忆"这一概念，根植于人工智能与自然语言处理领域，特别是针对具有深度学习能力的大型语言模型而言，它指的是模型在与用户进行交互式对话过程中，能够追踪、理解并利用先前对话上下文的能力。
-此机制使得大模型不仅能够响应即时的输入请求，还能基于之前的交流内容能够在对话中记住先前的对话内容，并根据这些信息进行后续的响应。这种记忆机制使得模型能够在对话中持续跟踪和理解用户的意图和上下文，从而实现更自然和连贯的对话。
-
-我们在调用大模型的过程中，如果自己维护多轮的对话记忆，通常情况下调用代码如下
-
-```java
-import java.util.ArrayList;
-
-List<Message> messages = new ArrayList<>();
-
-//第一轮对话
-messages.add(new SystemMessage("你是一个旅游规划师"));
-messages.add(new UserMessage("我想去新疆"));
-ChatResponse response = chatModel.call(new Prompt(messages));
-String content = response.getResult().getOutput().getContent();
-        
-messages.add(new AssistantMessage(content));
-
-        //第二轮对话
-messages.add(new UserMessage("能帮我推荐一些旅游景点吗?"));
-response = chatModel.call(new Prompt(messages));
-content = response.getResult().getOutput().getContent();
-
-messages.add(new AssistantMessage(content));
-
-        //第三轮对话
-messages.add(new UserMessage("那里这两天的天气如何?"));
-response = chatModel.call(new Prompt(messages));
-content = response.getResult().getOutput().getContent();
-
-System.out.printf("content: %s\n", content);
-
-```
-
-## 基于memory的对话记忆
-
-spring-ai-alibaba支持基于chat memory的对话记忆，也就是不需要调用显示的记录每一轮的对话历史。下边是一个基于内存存储的对话记忆实现:
-
-```java
-        //初始化基于内存的对话记忆
-        ChatMemory chatMemory = new InMemoryChatMemory();
-
-        DashScopeChatModel chatModel = ...;
-        ChatClient chatClient = ChatClient.builder(dashscopeChatModel)
-        .defaultAdvisors(new MessageChatMemoryAdvisor(chatMemory))
-        .build();
-
-        //对话记忆的唯一标识
-        String conversantId = UUID.randomUUID().toString();
-
-        ChatResponse response = chatClient
-                .prompt()
-                .user("我想去新疆")
-                .advisors(spec -> spec.param(CHAT_MEMORY_CONVERSATION_ID_KEY, conversantId)
-                        .param(CHAT_MEMORY_RETRIEVE_SIZE_KEY, 10))
-                .call()
-                .chatResponse();
-        String content = response.getResult().getOutput().getContent();
-        Assertions.assertNotNull(content);
-
-        logger.info("content: {}", content);
-
-        response = chatClient
-                .prompt()
-                .user("可以帮我推荐一些美食吗")
-                .advisors(spec -> spec.param(CHAT_MEMORY_CONVERSATION_ID_KEY, conversantId)
-                        .param(CHAT_MEMORY_RETRIEVE_SIZE_KEY, 10))
-                .call()
-                .chatResponse();
-        content = response.getResult().getOutput().getContent();
-        Assertions.assertNotNull(content);
-
-        logger.info("content: {}", content);
-
-```
-
-当然，开发者也可以自行实现ChatMemory基于类似于文件、Redis等方式进行上下文内容的存储和记录。
\ No newline at end of file
diff --git a/src/content/docs/ai/en/tutorials/prompt.md b/src/content/docs/ai/en/tutorials/prompt.md
deleted file mode 100644
index 7104b5350..000000000
--- a/src/content/docs/ai/en/tutorials/prompt.md
+++ /dev/null
@@ -1,183 +0,0 @@
----
-title: 提示词 (Prompt)
-keywords: [Spring AI,通义千问,百炼,智能体应用]
-description: "Spring AI 与通义千问集成，使用 Spring AI 开发 Java AI 应用。"
----
-
-Prompt 是引导 AI 模型生成特定输出的输入格式，Prompt 的设计和措辞会显著影响模型的响应。
-
-Prompt 最开始只是简单的字符串，随着时间的推移，prompt 逐渐开始包含特定的占位符，例如 AI 模型可以识别的 “USER:”、“SYSTEM:” 等。阿里云通义模型可通过将多个消息字符串分类为不同的角色，然后再由 AI 模型处理，为 prompt 引入了更多结构。每条消息都分配有特定的角色，这些角色对消息进行分类，明确 AI 模型提示的每个部分的上下文和目的。这种结构化方法增强了与 AI 沟通的细微差别和有效性，因为 prompt 的每个部分在交互中都扮演着独特且明确的角色。
-
-Prompt 中的主要角色（Role）包括：
-
-* 系统角色（System Role）：指导 AI 的行为和响应方式，设置 AI 如何解释和回复输入的参数或规则。这类似于在发起对话之前向 AI 提供说明。
-* 用户角色（User Role）：代表用户的输入 - 他们向 AI 提出的问题、命令或陈述。这个角色至关重要，因为它构成了 AI 响应的基础。
-* 助手角色（Assistant Role）：AI 对用户输入的响应。这不仅仅是一个答案或反应，它对于保持对话的流畅性至关重要。通过跟踪 AI 之前的响应（其“助手角色”消息），系统可确保连贯且上下文相关的交互。助手消息也可能包含功能工具调用请求信息。它就像 AI 中的一个特殊功能，在需要执行特定功能（例如计算、获取数据或不仅仅是说话）时使用。
-* 工具/功能角色（Tool/Function Role）：工具/功能角色专注于响应工具调用助手消息返回附加信息。
-
-
-## API 概览
-### Prompt
-通常使用 ChatModel 的 call() 方法，该方法接受 Prompt 实例并返回 ChatResponse。
-
-Prompt 类充当有组织的一系列 Message 对象和请求 ChatOptions 的容器。每条消息在提示中都体现了独特的角色，其内容和意图各不相同。这些角色可以包含各种元素，从用户查询到 AI 生成的响应再到相关背景信息。这种安排可以实现与 AI 模型的复杂而详细的交互，因为提示是由多条消息构成的，每条消息都被分配了在对话中扮演的特定角色。
-
-下面是 Prompt 类的截断版本，为简洁起见省略了构造函数和实用方法：
-
-```java
-public class Prompt implements ModelRequest<List<Message>> {
-
-    private final List<Message> messages;
-
-    private ChatOptions chatOptions;
-}
-```
-
-#### Message
-Message 接口封装了一个提示文本、一组元数据属性以及一个称为 MessageType 的分类。
-
-该接口定义如下：
-
-```java
-public interface Content {
-
-	String getContent();
-
-	Map<String, Object> getMetadata();
-}
-
-public interface Message extends Content {
-
-	MessageType getMessageType();
-}
-```
-
-Message 接口的各种实现对应 AI 模型可以处理的不同类别的消息。模型根据对话角色区分消息类别。
-
-![message class diagram](https://img.alicdn.com/imgextra/i4/O1CN01LoRnWM1iHkvWVQTbd_!!6000000004388-0-tps-4379-3653.jpg)
-
-
-#### Role
-
-角色在 Spring AI 中表示为枚举，如下所示：
-
-```java
-public enum MessageType {
-	USER("user"),
-	ASSISTANT("assistant"),
-	SYSTEM("system"),
-	TOOL("tool");
-}
-```
-
-### Prompt Template
-
-Spring AI 中用于提示模板的关键组件是 PromptTemplate 类。该类使用 Terence Parr 开发的 OSS StringTemplate 引擎来构建和管理提示。PromptTemplate 类旨在促进结构化提示的创建，然后将其发送到 AI 模型进行处理
-
-```java
-public class PromptTemplate implements PromptTemplateActions, PromptTemplateMessageActions {
-    // Other methods to be discussed later
-}
-```
-
-该类实现的接口支持提示创建的不同方面：
-
-PromptTemplateStringActions 专注于创建和呈现提示字符串，代表提示生成的最基本形式。
-
-PromptTemplateMessageActions 专门用于通过生成和操作 Message 对象来创建提示。
-
-PromptTemplateActions 旨在返回 Prompt 对象，该对象可以传递给 ChatModel 以生成响应。
-
-虽然这些接口可能在许多项目中没有得到广泛使用，但它们展示了创建提示的不同方法。
-
-实现的接口是
-
-```java
-public interface PromptTemplateStringActions {
-
-	String render();
-
-	String render(Map<String, Object> model);
-
-}
-```
-
-方法 String render()：将提示模板渲染为最终字符串格式，无需外部输入，适用于没有占位符或动态内容的模板。
-
-方法 String render(Map<String, Object> model)：增强渲染功能以包含动态内容。它使用 Map<String, Object>，其中映射键是提示模板中的占位符名称，值是要插入的动态内容。
-
-```java
-public interface PromptTemplateMessageActions {
-
-	Message createMessage();
-
-    Message createMessage(List<Media> mediaList);
-
-	Message createMessage(Map<String, Object> model);
-
-}
-```
-
-方法 Message createMessage()：创建一个不带附加数据的 Message 对象，用于静态或预定义消息内容。
-
-方法 Message createMessage(List<Media> mediaList)：创建一个带有静态文本和媒体内容的 Message 对象。
-
-方法 Message createMessage(Map<String, Object> model)：扩展消息创建以集成动态内容，接受 Map<String, Object>，其中每个条目代表消息模板中的占位符及其对应的动态值。
-
-```java
-public interface PromptTemplateActions extends PromptTemplateStringActions {
-
-	Prompt create();
-
-	Prompt create(ChatOptions modelOptions);
-
-	Prompt create(Map<String, Object> model);
-
-	Prompt create(Map<String, Object> model, ChatOptions modelOptions);
-
-}
-```
-
-方法 Prompt create()：生成不带外部数据输入的 Prompt 对象，非常适合静态或预定义提示。
-
-方法 Prompt create(ChatOptions modelOptions)：生成一个 Prompt 对象，无需外部数据输入，但具有聊天请求的特定选项。
-
-方法 Prompt create(Map<String, Object> model)：扩展提示创建功能以包含动态内容，采用 Map<String, Object>，其中每个映射条目都是提示模板中的占位符及其关联的动态值。
-
-方法 Prompt create(Map<String, Object> model, ChatOptions modelOptions)：扩展提示创建功能以包含动态内容，采用 Map<String, Object>，其中每个映射条目都是提示模板中的占位符及其关联的动态值，以及聊天请求的特定选项。
-
-## 使用示例
-
-完整示例源码请参见 [prompt-example](https://github.com/alibaba/spring-ai-alibaba/tree/main/spring-ai-alibaba-examples/prompt-example)。
-
-```java
-PromptTemplate promptTemplate = new PromptTemplate("Tell me a {adjective} joke about {topic}");
-
-Prompt prompt = promptTemplate.create(Map.of("adjective", adjective, "topic", topic));
-
-return chatModel.call(prompt).getResult();
-```
-
-
-
-```java
-String userText = """
-    Tell me about three famous pirates from the Golden Age of Piracy and why they did.
-    Write at least a sentence for each pirate.
-    """;
-
-Message userMessage = new UserMessage(userText);
-
-String systemText = """
-  You are a helpful AI assistant that helps people find information.
-  Your name is {name}
-  You should reply to the user's request with your name and also in the style of a {voice}.
-  """;
-
-SystemPromptTemplate systemPromptTemplate = new SystemPromptTemplate(systemText);
-Message systemMessage = systemPromptTemplate.createMessage(Map.of("name", name, "voice", voice));
-
-Prompt prompt = new Prompt(List.of(userMessage, systemMessage));
-
-List<Generation> response = chatModel.call(prompt).getResults();
-```
\ No newline at end of file
diff --git a/src/content/docs/ai/en/tutorials/retriever.md b/src/content/docs/ai/en/tutorials/retriever.md
deleted file mode 100644
index c92b69105..000000000
--- a/src/content/docs/ai/en/tutorials/retriever.md
+++ /dev/null
@@ -1,124 +0,0 @@
----
-title: 文档检索 (Document Retriever)
-keywords: [Spring AI,通义千问,百炼,智能体应用]
-description: "Spring AI 与通义千问集成，使用 Spring AI 开发 Java AI 应用。"
----
-
-## 核心概念
-文档检索（`DocumentRetriever`）是一种信息检索技术，旨在从大量未结构化或半结构化文档中快速找到与特定查询相关的文档或信息。文档检索通常以在线(online)方式运行。
-
-`DocumentRetriever`通常基于向量搜索。它将用户的查询问题(query)转化为Embeddings后，在存储文档中进行相似性搜索，返回相关的片段。片段的用途之一是作为提示词(prompt)的一部分，发送给大模型(LLM)汇总处理后，作为答案呈现给用户。
-
-`DocumentRetriever API`提供了简单、灵活的方式，供开发者使用自定义的检索系统。
-
-## API介绍
-本节介绍DocumentRetriever的接口和类。
-### DocumentRetriever
-```java
-public interface DocumentRetriever extends Function<String, List<Document>> {
-    List<Document> retrieve(String query);
-
-    default List<Document> apply(String query) {
-        return this.retrieve(query);
-    }
-}
-```
-DocumentRetriever API简单地将用户的查询作为输入，返回文档片段(`Document`)的列表。
-
-通过`retrieve`方法，用户可以执行自定义的检索步骤。
-
-#### Document
-`Document`表示一个文档片段，它包含一个文本内容，以及一个或多个元数据。
-```java
-@JsonIgnoreProperties({"contentFormatter"})
-public class Document implements MediaContent {
-    public static final ContentFormatter DEFAULT_CONTENT_FORMATTER = DefaultContentFormatter.defaultConfig();
-    public static final String EMPTY_TEXT = "";
-    private final String id;
-    private Map<String, Object> metadata;
-    private final String content;
-    private final Collection<Media> media;
-    @JsonProperty(
-            index = 100
-    )
-    private float[] embedding;
-    @JsonIgnore
-    private ContentFormatter contentFormatter;
-
-    @JsonCreator(
-            mode = Mode.PROPERTIES
-    )
-    // other methods omitted
-}
-```
-## 示例用法
-Spring AI Alibaba已经集成了`阿里云百炼平台`，接下来介绍基于阿里云百炼平台调用 DocumentRetriever API。
-
-### 准备工作
-由于百炼平台仅支持云端检索，因此在开始之前，参考如下链接获取API-KEY：[获取API-KEY](https://help.aliyun.com/zh/model-studio/developer-reference/get-api-key)。
-然后，在项目环境中设置API-KEY，有两种方式：
-
-- 方式一：设置`configuration properties：spring.ai.dashscope.api-key` 为上述API-KEY。
-- 方式二：设置环境变量`export SPRING_AI_DASHSCOPE_API_KEY=<YOUR API  KEY>`
-
-### Auto-configuration
-Spring AI 为 DashScopeDocumentRetriever 提供了 Spring Boot 的自动配置。要启用此功能，请将以下依赖项添加到您项目的 Maven`pom.xml`文件中：
-```xml
-<dependency>
-    <groupId>com.alibaba.cloud.ai</groupId>
-    <artifactId>spring-ai-alibaba-starter</artifactId>
-    <version>1.0.0-M2.1</version>
-</dependency>
-```
-或者添加到您的Gradle`build.gradle`文件中：
-```gradle
-dependencies {
-    implementation 'com.alibaba.cloud.ai:spring-ai-alibaba-starter:1.0.0-M2.1'
-}
-```
-#### Retriever Properties
-前缀`spring.ai.dashscope`是用于配置连接至 DashScope 的属性前缀。
-
-| Property                       | Action          | Default |
-|:-------------------------------|:----------------|---------|
-| `spring.ai.dashscope.api-key`  | 来自百炼平台的API KEY  | -       |
-
-
-```tips
-所有以 spring.ai.dashscope 开头的属性都可以在构造DashScopeDocumentRetriever时传入Runtime Options来覆盖。
-```
-
-### Runtime Options
-`DashScopeDocumentRetrieverOptions`提供了DashScopeDocumentRetriever的配置信息，它通过构建器创建选项。
-
-在构造`DashScopeDocumentRetriever`时，通过将一个`DashScopeDocumentRetrieverOptions`实例传入，已完成配置。
-
-例如，使用指定的知识库：
-```java
-DocumentRetriever retriever = new DashScopeDocumentRetriever(dashscopeApi,
-        DashScopeDocumentRetrieverOptions.builder()
-                .withIndexName("spring-ai知识库")
-                .build());
-```
-### 示例代码
-该示例将创建一个`DashScopeDocumentRetriever`实例，在指定的知识库上执行检索操作。以下是简单的`@Controller`类的示例，它使用了该 DashScopeDocumentRetriever 实例。
-```properties
-spring.ai.dashscope.api-key=YOUR_API_KEY
-```
-```java
-@RestController
-public class RetrieverController {
-
-    private final DocumentRetriever documentRetriever;
-
-    @Autowired
-    public RetrieverController(DocumentRetriever documentRetriever) {
-        this.documentRetriever = documentRetriever;
-    }
-
-    @GetMapping("/ai/retrieve")
-    public List<Document> retrieve(@RequestParam(value = "message", defaultValue = "What's spring ai") String message) {
-        return this.documentRetriever.retrieve(message);
-    }
-}
-```
diff --git a/src/content/docs/ai/en/tutorials/structured-output.md b/src/content/docs/ai/en/tutorials/structured-output.md
deleted file mode 100644
index fbcce5520..000000000
--- a/src/content/docs/ai/en/tutorials/structured-output.md
+++ /dev/null
@@ -1,104 +0,0 @@
----
-title: 格式化输出(Structured Output)
-keywords: [Chat Model, 聊天, 对话]
-description: "Spring AI 与通义千问集成，使用 Spring AI 开发 Java AI 应用。"
----
-
-如果您想从 LLM 接收结构化输出，Structured Output 可以协助将 `ChatModel/ChatClient` 方法的返回类型从 String 更改为其他类型。
-
-LLM 生成结构化输出的能力对于依赖可靠解析输出值的下游应用程序非常重要。开发人员希望快速将 AI 模型的结果转换为可以传递给其他应用程序函数和方法的数据类型，例如 JSON、XML 或 Java 类。Spring AI 结构化输出转换器有助于将 LLM 输出转换为结构化格式。
-
-![structured output flow](https://img.alicdn.com/imgextra/i2/O1CN01JozLPb1zIX4DMaXTO_!!6000000006691-0-tps-2809-1423.jpg)
-
-在 LLM 调用之前，转换器会将期望的输出格式（output format instruction）附加到 prompt 中，为模型提供生成所需输出结构的明确指导，这些指令充当蓝图，塑造模型的响应以符合指定的格式。以下是此类格式说明的示例：
-
-```text
-Your response should be in JSON format.
-The data structure for the JSON should match this Java class: java.util.HashMap
-Do not include any explanations, only provide a RFC8259 compliant JSON response following this format without deviation.
-```
-
-在 LLM 调用之后，转换器获取模型的输出文本并将其转换为结构化类型的实例，此转换过程涉及解析原始文本输出并将其映射到相应的结构化数据表示，例如 JSON、XML 或特定于域的数据结构。
-
-## API 概述
-
-当前 Spring AI 提供的 Converter 实现有 `AbstractConversionServiceOutputConverter`, `AbstractMessageOutputConverter`, `BeanOutputConverter`, `MapOutputConverter` and `ListOutputConverter`。
-
-![structured output class hierarchy](https://img.alicdn.com/imgextra/i2/O1CN01JTh3dN1iXmmroxnYo_!!6000000004423-0-tps-2864-1396.jpg)
-
-* BeanOutputConverter<T> - 使用指定的 Java 类（例如 Bean）或 ParameterizedTypeReference 配置，此转换器指示 AI 模型生成符合 DRAFT_2020_12 的 JSON 响应，JSON 模式派生自指定的 Java 类，随后，它利用 ObjectMapper 将 JSON 输出反序列化为目标类的 Java 对象实例。
-* MapOutputConverter - 该实现指导 AI 模型生成符合 RFC8259 的 JSON 响应，此外，它还包含一个转换器实现，该实现利用提供的 MessageConverter 将 JSON 负载转换为 java.util.Map<String, Object> 实例。
-* ListOutputConverter - 该实现指导 AI 模型生成逗号分隔的格式化输出，最终转换器将模型文本输出转换为 java.util.List。
-
-## 使用示例
-
-格式化输出工具的使用非常简单，以下是 `ChatClient` 和 `ChatModel` 两种使用示例。完整是示例源码请参见 [structured-output-example](https://github.com/alibaba/spring-ai-alibaba/tree/main/spring-ai-alibaba-examples/structured-output-example)
-
-假设我们期望将模型输出转换为以下结构体：
-```java
-record ActorsFilms(String actor, List<String> movies) {
-}
-```
-
-### ChatClient
-将模型响应转换为 ActorsFilms 对象实例：
-
-```java
-ActorsFilms actorsFilms = ChatClient.create(chatModel).prompt()
-        .user(u -> u.text("Generate the filmography of 5 movies for {actor}.")
-                    .param("actor", "Tom Hanks"))
-        .call()
-        .entity(ActorsFilms.class);
-```
-
-或者，将模型响应转换为 List<ActorsFilms> 对象实例：
-
-```java
-List<ActorsFilms> actorsFilms = ChatClient.create(chatModel).prompt()
-        .user("Generate the filmography of 5 movies for Tom Hanks and Bill Murray.")
-        .call()
-        .entity(new ParameterizedTypeReference<List<ActorsFilms>>() {});
-```
-
-将模型响应转换为 Map<String, Object>：
-
-```java
-Map<String, Object> result = ChatClient.create(chatModel).prompt()
-        .user(u -> u.text("Provide me a List of {subject}")
-                    .param("subject", "an array of numbers from 1 to 9 under their key name 'numbers'"))
-        .call()
-        .entity(new ParameterizedTypeReference<Map<String, Object>>() {});
-```
-
-使用 `ListOutputConverter` 将模型响应转换为 List<String>：
-
-```java
-List<String> flavors = ChatClient.create(chatModel).prompt()
-                .user(u -> u.text("List five {subject}")
-                            .param("subject", "ice cream flavors"))
-                .call()
-                .entity(new ListOutputConverter(new DefaultConversionService()));
-```
-
-### ChatModel
-
-如果您使用的更底层的原子 API，则使用如下方式进行格式化输出转换：
-
-```java
-BeanOutputConverter<ActorsFilms> beanOutputConverter =
-    new BeanOutputConverter<>(ActorsFilms.class);
-
-String format = beanOutputConverter.getFormat();
-
-String actor = "Tom Hanks";
-
-String template = """
-        Generate the filmography of 5 movies for {actor}.
-        {format}
-        """;
-
-Generation generation = chatModel.call(
-    new PromptTemplate(template, Map.of("actor", actor, "format", format)).create()).getResult();
-
-ActorsFilms actorsFilms = beanOutputConverter.convert(generation.getOutput().getContent());
-```
diff --git a/src/content/docs/ai/en/tutorials/vectorstore.md b/src/content/docs/ai/en/tutorials/vectorstore.md
deleted file mode 100644
index 913ec91c1..000000000
--- a/src/content/docs/ai/en/tutorials/vectorstore.md
+++ /dev/null
@@ -1,145 +0,0 @@
----
-title: 向量存储(Vector Store)
-keywords: [Spring AI,通义千问,百炼,智能体应用]
-description: "Spring AI 与通义千问集成，使用 Spring AI 开发 Java AI 应用。"
----
-
-## 核心概念
-向量存储（`VectorStore`）是一种用于存储和检索高维向量数据的数据库或存储解决方案，它特别适用于处理那些经过嵌入模型转化后的数据。在 VectorStore 中，查询与传统关系数据库不同。它们执行相似性搜索，而不是精确匹配。当给定一个向量作为查询时，VectorStore 返回与查询向量“相似”的向量。
-
-VectorStore 用于将您的数据与 AI 模型集成。在使用它们时的第一步是将您的数据加载到矢量数据库中。然后，当要将用户查询发送到 AI 模型时，首先检索一组相似文档。然后，这些文档作为用户问题的上下文，并与用户的查询一起发送到 AI 模型。这种技术被称为检索增强生成（`Retrieval Augmented Generation，RAG`）。
-
-VectorStore API提供了简单易用的接口供开发者对 VectorStore 进行操作，接下来的部分描述相关接口以及一些高层次的示例用法。
-
-## API介绍
-本节是对 Spring AI 框架中`VectorStore`接口及其相关类的指南。
-
-Spring AI 提供了一个抽象化的 API，通过 VectorStore 接口与向量数据库进行交互。
-### VectorStore
-以下是`VectorStore`接口的定义：
-```java
-public interface VectorStore extends DocumentWriter {
-    default String getName() {
-        return this.getClass().getSimpleName();
-    }
-
-    void add(List<Document> documents);
-
-    default void accept(List<Document> documents) {
-        this.add(documents);
-    }
-
-    Optional<Boolean> delete(List<String> idList);
-
-    List<Document> similaritySearch(SearchRequest request);
-
-    default List<Document> similaritySearch(String query) {
-        return this.similaritySearch(SearchRequest.query(query));
-    }
-}
-```
-以及相关的`SearchRequest`构建器：
-```java
-public class SearchRequest {
-
-    public final String query;
-    private int topK = 4;
-    private double similarityThreshold = SIMILARITY_THRESHOLD_ALL;
-    private Filter.Expression filterExpression;
-
-    public static SearchRequest query(String query) { return new SearchRequest(query); }
-
-    private SearchRequest(String query) { this.query = query; }
-
-    public SearchRequest withTopK(int topK) {...}
-    public SearchRequest withSimilarityThreshold(double threshold) {...}
-    public SearchRequest withSimilarityThresholdAll() {...}
-    public SearchRequest withFilterExpression(Filter.Expression expression) {...}
-    public SearchRequest withFilterExpression(String textExpression) {...}
-
-    public String getQuery() {...}
-    public int getTopK() {...}
-    public double getSimilarityThreshold() {...}
-    public Filter.Expression getFilterExpression() {...}
-}
-```
-
-要将数据插入 VectorStore，应先将其封装在`Document`对象中。`Document`类封装了来自数据源（如 PDF 或 Word 文档）的内容，并将文本表示为字符串。它还包含键值对形式的元数据，包括文件名等详细信息。
-
-在将文本内容插入 VectorStore 时，使用 EmbeddingModel 将文本内容转换为数值数组或float[]，这一步称为向量 Embedding。EmbeddingModel 用于将单词、句子或段落转换为这些向量 Embeddings。
-
-VectorStore 的作用是存储并支持对这些 Embeddings 的相似性搜索，它不会生成 Embeddings 本身。因此，VectorStore 需要和 EmbeddingModel 一起使用。
-
-接口中的`similaritySearch`方法允许检索与给定查询字符串相似的文档，你可以微调相似性搜索的这些参数：
-- `k`：一个整数，指定要返回的相似文档的最大数量。这通常被称为 “top K” 搜索或 “K最近邻”（KNN）。
-- `threshold`：一个值从 0 到 1 的双精度数，接近1的值表示更高的相似性。默认情况下，如果您设置了阈值为0.75，那么只有相似度超过此值的文档才会被返回。
-- `Filter.Expression`：一个用于传递流畅 DSL（特定域语言）表达式的类，其功能类似于 SQL 中的 “where”子句，但它仅适用于`Document`的元数据键值对。
-- `filterExpression`：基于 ANTLR4 的外部 DSL，接受字符串形式的过滤表达式。例如，对于元数据键如country、year 和`isActive`，您可以使用如下表达式：`country == 'UK' && year >= 2020 && isActive == true`。
-
-## 示例用法
-Spring AI Alibaba已经集成了`阿里云百炼平台`，接下来介绍基于阿里云百炼平台调用 VectorStore API。
-### 准备工作
-在开始之前，参考如下链接获取API-KEY：[获取API-KEY](https://help.aliyun.com/zh/model-studio/developer-reference/get-api-key)。
-然后，在项目环境中设置API-KEY，有两种方式：
-
-- 方式一：设置`configuration properties：spring.ai.dashscope.api-key` 为上述API-KEY。
-- 方式二：设置环境变量`export SPRING_AI_DASHSCOPE_API_KEY=<YOUR API  KEY>`
-### Auto-configuration
-Spring AI 为 VectorStore 提供了 Spring Boot 的自动配置。要启用此功能，请将以下依赖项添加到您项目的 Maven`pom.xml`文件中：
-```xml
-<dependency>
-    <groupId>com.alibaba.cloud.ai</groupId>
-    <artifactId>spring-ai-alibaba-starter</artifactId>
-    <version>1.0.0-M2.1</version>
-</dependency>
-```
-或者添加到您的Gradle`build.gradle`文件中：
-```gradle
-dependencies {
-    implementation 'com.alibaba.cloud.ai:spring-ai-alibaba-starter:1.0.0-M2.1'
-}
-```
-
-#### VectorStore Properties
-前缀`spring.ai.dashscope`是用于配置连接至 DashScope 的属性前缀。
-
-| Property                       | Action          | Default |
-|:-------------------------------|:----------------|---------|
-| `spring.ai.dashscope.api-key`  | 来自百炼平台的API KEY  | -       |
-
-```tips
-所有以 spring.ai.dashscope 开头的属性都可以在构造 DashScopeCloudStore 时传入Runtime Options来覆盖。
-```
-
-### Runtime Options
-`DashScopeStoreOptions`提供了 DashScopeCloudStore 的配置信息，它通过构造函数来创建选项。
-
-在构造`DashScopeCloudStore`时，通过将一个`DashScopeStoreOptions`实例传入，已完成配置。
-
-例如，使用指定的知识库：
-```java
-DashScopeCloudStore cloudStore = new DashScopeCloudStore(
-        dashscopeApi, new DashScopeStoreOptions("spring-ai知识库"));
-```
-### 示例代码
-该示例将创建一个`DashScopeCloudStore`实例，在指定的知识库上执行检索操作。以下是简单的`@Controller`类的示例，它使用了该 DashScopeCloudStore 实例。
-```properties
-spring.ai.dashscope.api-key=YOUR_API_KEY
-```
-```java
-@RestController
-public class StoreController {
-
-    private final DashScopeCloudStore dashScopeCloudStore;
-
-    @Autowired
-    public StoreController(DashScopeCloudStore dashScopeCloudStore) {
-        this.dashScopeCloudStore = dashScopeCloudStore;
-    }
-
-    @GetMapping("/ai/search")
-    public List<Document> store(@RequestParam(value = "message", defaultValue = "What's spring ai") String message) {
-        return this.dashScopeCloudStore.similaritySearch(message);
-    }
-}
-```
\ No newline at end of file
diff --git a/src/content/docs/ai/zh-cn/concepts.md b/src/content/docs/ai/zh-cn/concepts.md
deleted file mode 100644
index 099c98d8c..000000000
--- a/src/content/docs/ai/zh-cn/concepts.md
+++ /dev/null
@@ -1,151 +0,0 @@
----
-title: 核心概念
-keywords: [Spring Cloud Alibaba核心概念, ]
-description: "Spring Cloud Alibaba核心概念"
----
-
-# 核心概念
-
-本节介绍 Spring AI 框架使用的核心概念。我们建议仔细阅读，以了解框架实现背后的思想。
-
-## 模型（Model）
-
-AI 模型是旨在处理和生成信息的算法，通常模仿人类的认知功能。通过从大型数据集中学习模式和见解，这些模型可以做出预测、文本、图像或其他输出，从而增强各个行业的各种应用。
-
-AI 模型有很多种，每种都适用于特定的用例。虽然 ChatGPT 及其生成 AI 功能通过文本输入和输出吸引了用户，但许多模型和公司都提供不同的输入和输出。在 ChatGPT 之前，许多人都对文本到图像的生成模型着迷，例如 Midjourney 和 Stable Diffusion。
-
-![spring-ai-concepts-model-types](https://img.alicdn.com/imgextra/i2/O1CN01otCVsl22MbQzFKYzJ_!!6000000007106-0-tps-2472-1618.jpg)
-
-Spring AI 目前支持以语言、图像和音频形式处理输入和输出的模型。上表中的最后一行接受文本作为输入并输出数字，通常称为嵌入文本（Embedding Text），用来表示 AI 模型中使用的内部数据结构。Sprig AI 提供了对 Embedding 的支持以支持开发更高级的应用场景。
-
-GPT 等模型的独特之处在于其预训练特性，正如 GPT 中的“P”所示——Chat Generative Pre-trained Transformer。这种预训练功能将 AI 转变为通用的开发工具，开发者使用这种工具不再需要广泛的机器学习或模型训练背景。
-
-## 提示（Prompt）
-
-Prompt作为语言基础输入的基础，指导AI模型生成特定的输出。对于熟悉ChatGPT的人来说，Prompt似乎只是输入到对话框中的文本，然后发送到API。然而，它的内涵远不止于此。在许多AI模型中，Prompt的文本不仅仅是一个简单的字符串。
-
-ChatGPT的API包含多个文本输入，每个文本输入都有其角色。例如，系统角色用于告知模型如何行为并设定交互的背景。还有用户角色，通常是来自用户的输入。
-
-撰写有效的Prompt既是一门艺术，也是一门科学。ChatGPT旨在模拟人类对话，这与使用SQL“提问”有很大的区别。与AI模型的交流就像与另外一个人对话一样。
-
-这种互动风格的重要性使得“Prompt工程”这一学科应运而生。现在有越来越多的技术被提出，以提高Prompt的有效性。投入时间去精心设计Prompt可以显著改善生成的输出。
-
-分享Prompt已成为一种共同的实践，且正在进行积极的学术研究。例如，最近的一篇研究论文发现，最有效的Prompt之一可以以“深呼吸一下，分步进行此任务”开头。这表明语言的重要性之高。我们尚未完全了解如何充分利用这一技术的前几代版本，例如ChatGPT 3.5，更不用说正在开发的新版本了。
-
-### 提示词模板（Prompt Template）
-
-创建有效的Prompt涉及建立请求的上下文，并用用户输入的特定值替换请求的部分内容。这个过程使用传统的基于文本的模板引擎来进行Prompt的创建和管理。Spring AI采用开源库StringTemplate来实现这一目的。
-
-例如，考虑以下简单的Prompt模板：
-
-```text
-Tell me a {adjective} joke about {content}.
-```
-
-在Spring AI中，Prompt模板可以类比于Spring MVC架构中的“视图”。一个模型对象，通常是java.util.Map，提供给Template，以填充模板中的占位符。渲染后的字符串成为传递给AI模型的Prompt的内容。
-
-传递给模型的Prompt在具体数据格式上有相当大的变化。从最初的简单字符串开始，Prompt逐渐演变为包含多条消息的格式，其中每条消息中的每个字符串代表模型的不同角色。
-
-## 嵌入（Embedding）
-
-嵌入（Embedding）是文本、图像或视频的数值表示，能够捕捉输入之间的关系，Embedding通过将文本、图像和视频转换为称为向量（Vector）的浮点数数组来工作。这些向量旨在捕捉文本、图像和视频的含义，Embedding数组的长度称为向量的维度。
-
-通过计算两个文本片段的向量表示之间的数值距离，应用程序可以确定用于生成嵌入向量的对象之间的相似性。
-
-![spring-ai-embeddings](https://img.alicdn.com/imgextra/i1/O1CN01EnE3i61j2vin5eTGV_!!6000000004491-0-tps-3518-1136.jpg)
-
-作为一名探索人工智能的Java开发者，理解这些向量表示背后的复杂数学理论或具体实现并不是必需的。对它们在人工智能系统中的作用和功能有基本的了解就足够了，尤其是在将人工智能功能集成到您的应用程序中时。
-
-Embedding在实际应用中，特别是在检索增强生成（RAG）模式中，具有重要意义。它们使数据能够在语义空间中表示为点，这类似于欧几里得几何的二维空间，但在更高的维度中。这意味着，就像欧几里得几何中平面上的点可以根据其坐标的远近关系而接近或远离一样，在语义空间中，点的接近程度反映了意义的相似性。关于相似主题的句子在这个多维空间中的位置较近，就像图表上彼此靠近的点。这种接近性有助于文本分类、语义搜索，甚至产品推荐等任务，因为它允许人工智能根据这些点在扩展的语义空间中的“位置”来辨别和分组相关概念。
-
-您可以将这个语义空间视为一个向量。
-
-## Token
-
-token是 AI 模型工作原理的基石。输入时，模型将单词转换为token。输出时，它们将token转换回单词。
-
-在英语中，一个token大约对应一个单词的 75%。作为参考，莎士比亚的全集总共约 90 万个单词，翻译过来大约有 120 万个token。
-
-![spring-ai-concepts-tokens](https://img.alicdn.com/imgextra/i3/O1CN01ciNztT1nJCFhQodzH_!!6000000005068-2-tps-1345-246.png)
-
-也许更重要的是 “token = 金钱”。在托管 AI 模型的背景下，您的费用由使用的token数量决定。输入和输出都会影响总token数量。
-
-此外，模型还受到 token 限制，这会限制单个 API 调用中处理的文本量。此阈值通常称为“上下文窗口”。模型不会处理超出此限制的任何文本。
-
-例如，ChatGPT3 的token限制为 4K，而 GPT4 则提供不同的选项，例如 8K、16K 和 32K。Anthropic 的 Claude AI 模型的token限制为 100K，而 Meta 的最新研究则产生了 1M token限制模型。
-
-要使用 GPT4 总结莎士比亚全集，您需要制定软件工程策略来切分数据并在模型的上下文窗口限制内呈现数据。Spring AI 项目可以帮助您完成此任务。
-
-## 结构化输出（Structured Output）
-
-即使您要求回复为 JSON ，AI 模型的输出通常也会以 `java.lang.String` 的形式出现。它可能是正确的 JSON，但它可能并不是你想要的 JSON 数据结构，它只是一个字符串。此外，在提示词 Prompt 中要求 “返回JSON” 并非 100% 准确。
-
-这种复杂性导致了一个专门领域的出现，涉及创建 Prompt 以产生预期的输出，然后将生成的简单字符串转换为可用于应用程序集成的数据结构。
-
-![结构化输出转换器架构](https://img.alicdn.com/imgextra/i3/O1CN01lqCPAC1Xbwc1MfYv7_!!6000000002943-0-tps-2809-1423.jpg)
-
-[结构化输出转换](./tutorials/structured-output/)采用精心设计的提示，通常需要与模型进行多次交互才能实现所需的格式。
-
-## 将您的数据和 API 引入 AI 模型
-
-如何让人工智能模型与不在训练集中的数据一同工作？
-
-请注意，GPT 3.5/4.0 数据集仅支持截止到 2021 年 9 月之前的数据。因此，该模型表示它不知道该日期之后的知识，因此它无法很好的应对需要用最新知识才能回答的问题。一个有趣的小知识是，这个数据集大约有 650GB。
-
-有三种技术可以定制 AI 模型以整合您的数据：
-
-* `Fine Tuning` 微调：这种传统的机器学习技术涉及定制模型并更改其内部权重。然而，即使对于机器学习专家来说，这是一个具有挑战性的过程，而且由于 GPT 等模型的大小，它极其耗费资源。此外，有些模型可能不提供此选项。
-* `Prompt Stuffing` 提示词填充：一种更实用的替代方案是将您的数据嵌入到提供给模型的提示中。考虑到模型的令牌限制，我们需要具备过滤相关数据的能力，并将过滤出的数据填充到在模型交互的上下文窗口中，这种方法俗称“提示词填充”。Spring AI 库可帮助您基于“提示词填充” 技术，也称为[检索增强生成 (RAG)](./#检索增强生成rag)实现解决方案。
-
-![prompt-stuffing](https://img.alicdn.com/imgextra/i3/O1CN01hRUT291k1O09cdQEU_!!6000000004623-0-tps-3249-1230.jpg)
-
-* [Function Calling](./tutorials/function-calling/)：此技术允许注册自定义的用户函数，将大型语言模型连接到外部系统的 API。Spring AI 大大简化了支持[函数调用](./tutorials/function-calling/)所需编写的代码。
-
-
-### 检索增强生成（RAG）
-
-一种称为检索增强生成 (RAG) 的技术已经出现，旨在解决为 AI 模型提供额外的知识输入，以辅助模型更好的回答问题。
-
-该方法涉及批处理式的编程模型，其中涉及到：从文档中读取非结构化数据、对其进行转换、然后将其写入矢量数据库。从高层次上讲，这是一个 ETL（提取、转换和加载）管道。矢量数据库则用于 RAG 技术的检索部分。
-
-在将非结构化数据加载到矢量数据库的过程中，最重要的转换之一是将原始文档拆分成较小的部分。将原始文档拆分成较小部分的过程有两个重要步骤：
-
-1. 将文档拆分成几部分，同时保留内容的语义边界。例如，对于包含段落和表格的文档，应避免在段落或表格中间拆分文档；对于代码，应避免在方法实现的中间拆分代码。
-2. 将文档的各部分进一步拆分成大小仅为 AI 模型令牌 token 限制的一小部分的部分。
-
-
-RAG 的下一个阶段是处理用户输入。当用户的问题需要由 AI 模型回答时，问题和所有“类似”的文档片段都会被放入发送给 AI 模型的提示中。这就是使用矢量数据库的原因，它非常擅长查找具有一定相似度的“类似”内容。
-
-![Spring AI RAG](https://img.alicdn.com/imgextra/i1/O1CN01zEQSHu1sQ8KTQSA2E_!!6000000005760-0-tps-3360-1859.jpg)
-
-* <a target="_blank" href="https://docs.spring.io/spring-ai/reference/api/etl-pipeline.html">ETL 管道</a> 提供了有关协调从数据源提取数据并将其存储在结构化向量存储中的流程的更多信息，确保在将数据传递给 AI 模型时数据具有最佳的检索格式。
-* [ChatClient - RAG](./tutorials/chat-client/#检索增强生成rag) 解释了如何使用`QuestionAnswerAdvisor` Advisor 在您的应用程序中启用 RAG 功能。
-
-
-### 函数调用（Function Calling）
-
-大型语言模型 (LLM) 在训练后即被冻结，导致知识陈旧，并且无法访问或修改外部数据。
-
-[Function Calling](https://docs.spring.io/spring-ai/reference/api/functions.html)机制解决了这些缺点，它允许您注册自己的函数，以将大型语言模型连接到外部系统的 API。这些系统可以为 LLM 提供实时数据并代表它们执行数据处理操作。
-
-Spring AI 大大简化了您需要编写的代码以支持函数调用。它为您处理函数调用对话。您可以将函数作为提供，`@Bean`然后在提示选项中提供该函数的 bean 名称以激活该函数。此外，您可以在单个提示中定义和引用多个函数。
-
-![Spring AI Function Calling](https://img.alicdn.com/imgextra/i3/O1CN01kiQh6L1hnWmm5gCAW_!!6000000004322-0-tps-3400-1838.jpg)
-
-* （1）执行聊天请求并发送函数定义信息。后者提供`name`（`description`例如，解释模型何时应调用该函数）和`input parameters`（例如，函数的输入参数模式）。
-* （2）当模型决定调用该函数时，它将使用输入参数调用该函数，并将输出返回给模型。
-* （3）Spring AI 为您处理此对话。它将函数调用分派给适当的函数，并将结果返回给模型。
-* （4）模型可以执行多个函数调用来检索所需的所有信息。
-* （5）一旦获取了所有需要的信息，模型就会生成响应。
-
-请关注[函数调用](https://docs.spring.io/spring-ai/reference/api/functions.html)文档以获取有关如何在不同 AI 模型中使用此功能的更多信息。
-
-## 评估人工智能的回答（Evaluation）
-
-有效评估人工智能系统回答的正确性，对于确保最终应用程序的准确性和实用性非常重要，一些新兴技术使得预训练模型本身能够用于此目的。
-
-Evaluation 评估过程涉及分析响应是否符合用户的意图、与查询的上下文强相关，一些指标如相关性、连贯性和事实正确性等都被用于衡量 AI 生成的响应的质量。
-
-一种方法是把用户的请求、模型的响应一同作为输入给到模型服务，对比模型给的响应或回答是否与提供的响应数据一致。
-
-此外，利用矢量数据库（Vector Database）中存储的信息作为补充数据可以增强评估过程，有助于确定响应的相关性。
diff --git a/src/content/docs/ai/zh-cn/get-started.md b/src/content/docs/ai/zh-cn/get-started.md
deleted file mode 100644
index c2a5f408b..000000000
--- a/src/content/docs/ai/zh-cn/get-started.md
+++ /dev/null
@@ -1,121 +0,0 @@
----
-title: 快速开始
-keywords: [Spring AI,通义千问,百炼,智能体应用]
-description: "Spring AI 与通义千问集成，使用 Spring AI 开发 Java AI 应用。"
----
-
-Spring AI Alibaba 实现了与阿里云通义模型的完整适配，接下来，我们将学习如何使用 spring ai alibaba 开发一个基于通义模型服务的智能聊天应用。
-
-## 快速体验示例
-
-> 注意：因为 Spring AI Alibaba 基于 Spring Boot 3.x 开发，因此本地 JDK 版本要求为 17 及以上。
-
-1. 下载项目
-	运行以下命令下载源码，进入 helloworld 示例目录：
-
-	```shell
-	git clone --depth=1 https://github.com/alibaba/spring-ai-alibaba.git
-	cd spring-ai-alibaba/spring-ai-alibaba-examples/helloworld-example
-	```
-
-2. 运行项目
-	首先，需要获取一个合法的 API-KEY 并设置 `AI_DASHSCOPE_API_KEY` 环境变量，可跳转 <a target="_blank" href="https://help.aliyun.com/zh/model-studio/developer-reference/get-api-key">阿里云百炼平台</a> 了解如何获取 API-KEY。
-
-	```shell
-	export AI_DASHSCOPE_API_KEY=${REPLACE-WITH-VALID-API-KEY}
-	```
-
-	启动示例应用：
-
-	```shell
-	./mvnw compile exec:java -Dexec.mainClass="com.alibaba.cloud.ai.example.helloworld.HelloWorldExampleApplication"
-	```
-
-	访问 `http://localhost:8080/ai/chat?input=给我讲一个笑话吧`，向通义模型提问并得到回答。
-
-## 示例开发指南
-以上示例本质上就是一个普通的 Spring Boot 应用，我们来通过源码解析看一下具体的开发流程。
-
-1. 添加依赖
-
-	首先，需要在项目中添加 `spring-ai-alibaba-starter` 依赖，它将通过 Spring Boot 自动装配机制初始化与阿里云通义大模型通信的 `ChatClient`、`ChatModel` 相关实例。
-
-	```xml
-	<dependency>	
-		<groupId>com.alibaba.cloud.ai</groupId>
-		<artifactId>spring-ai-alibaba-starter</artifactId>
-		<version>1.0.0-M2.1</version>
-	</dependency>
-	```
-
-    > 注意：由于 spring-ai 相关依赖包还没有发布到中央仓库，如出现 spring-ai-core 等相关依赖解析问题，请在您项目的 pom.xml 依赖中加入如下仓库配置。
-    >
-    > ```xml
-    > <repositories>
-    > 	<repository>
-    > 		<id>spring-milestones</id>
-    > 		<name>Spring Milestones</name>
-    > 		<url>https://repo.spring.io/milestone</url>
-    > 		<snapshots>
-    > 			<enabled>false</enabled>
-    > 		</snapshots>
-    > 	</repository>
-    > </repositories>
-    > ```
-
-2. 注入 ChatClient
-
-	接下来，在普通 Controller Bean 中注入 `ChatClient` 实例，这样你的 Bean 就具备与 AI 大模型智能对话的能力了。
-
-	```java
-	@RestController
-    @RequestMapping("/ai")
-	public class ChatController {
-	
-		private final ChatClient chatClient;
-	
-		public ChatController(ChatClient.Builder builder) {
-			this.chatClient = builder.build();
-		}
-	
-		@GetMapping("/chat")
-		public String chat(String input) {
-			return this.chatClient.prompt()
-					.user(input)
-					.call()
-					.content();
-		}
-	}
-	```
-
-	以上示例中，ChatClient 调用大模型使用的是默认参数，Spring AI Alibaba 还支持通过 `DashScopeChatOptions` 调整与模型对话时的参数，`DashScopeChatOptions` 支持两种不同维度的配置方式：
-
-	1. 全局默认值，即 `ChatClient` 实例初始化参数
-
-		可以在 `application.yaml` 文件中指定 `spring.ai.dashscope.chat.options.*` 或调用构造函数 `ChatClient.Builder.defaultOptions(options)`、`DashScopeChatModel(api, options)` 完成配置初始化。
-
-	2. 每次 Prompt 调用前动态指定
-
-		```java
-		ChatResponse response = chatModel.call(
-			new Prompt(
-				"Generate the names of 5 famous pirates.",
-				DashScopeChatOptions.builder()
-					.withModel("qwen-plus")
-					.withTemperature(0.4F)
-				.build()
-			));
-		```
-
-	关于 `DashScopeChatOptions` 配置项的详细说明，请查看参考手册。
-
-## 更多资料
-### 基础示例与API使用
-* [ChatClient 详细说明](./tutorials/chat-client/)
-* [Prompt Template 提示词模板](./tutorials/prompt/)
-* [Function Calling](./tutorials/function-calling/)
-
-### 高级示例
-* [使用 RAG 开发 Q&A 答疑助手](./practices/rag)
-* [具备连续对话能力的聊天机器人](./practices/memory)
-
diff --git a/src/content/docs/ai/zh-cn/overview.md b/src/content/docs/ai/zh-cn/overview.md
deleted file mode 100644
index d43d955e3..000000000
--- a/src/content/docs/ai/zh-cn/overview.md
+++ /dev/null
@@ -1,29 +0,0 @@
----
-title: Spring AI Alibaba 概述
-keywords: [Spring Cloud Alibaba,Spring AI,Tongyi Qianwen]
-description: "Spring AI 与通义千问集成，使用 Spring AI 开发 Java AI 应用。"
----
-## 什么是 Spring AI Alibaba？
-Spring AI Alibaba 开源项目基于 Spring AI 构建，是阿里云通义系列模型及服务在 Java AI 应用开发领域的最佳实践，提供高层次的 AI API 抽象与云原生基础设施集成方案，帮助开发者快速构建 AI 应用。
-
-<a target="_blank" href="https://img.alicdn.com/imgextra/i1/O1CN01uhDvMY22HZ4q1OZMM_!!6000000007095-2-tps-5440-2928.png"><image src="https://img.alicdn.com/imgextra/i1/O1CN01uhDvMY22HZ4q1OZMM_!!6000000007095-2-tps-5440-2928.png" /></a>
-
-Spring AI Alibaba 作为开发 AI 应用程序的基础框架，定义了以下抽象概念与 API，并提供了 API 与通义系列模型的适配。
-
-* 开发复杂 AI 应用的高阶抽象 Fluent API -- ChatClient
-* 提供多种大模型服务对接能力，包括主流开源与阿里云通义大模型服务（百炼）等
-* 支持的模型类型包括聊天、文生图、音频转录、文生语音等
-* 支持同步和流式 API，在保持应用层 API 不变的情况下支持灵活切换底层模型服务，支持特定模型的定制化能力（参数传递）
-* 支持 Structured Output，即将 AI 模型输出映射到 POJOs
-* 支持矢量数据库存储与检索
-* 支持函数调用 Function Calling
-* 支持构建 AI Agent 所需要的工具调用和对话内存记忆能力
-* 支持 RAG 开发模式，包括离线文档处理如 DocumentReader、Splitter、Embedding、VectorStore 等，支持 Retrieve 检索
-
-以上框架功能可让您实现常见 AI 应用的快速开发，例如 "通过文档进行问答" 或 "通过文档进行聊天" 等。
-
-## Spring AI 项目简介
-
-<a target="_blank" href="https://docs.spring.io/spring-ai/reference/index.html">Spring AI</a> 项目由 Spring 官方开源并维护的 AI 应用开发框架，该项目目标是简化包含人工智能（AI）功能的应用程序的开发，避免不必要的复杂性。该项目从著名的 Python 项目（例如 LangChain 和 LlamaIndex）中汲取灵感，但 Spring AI 并非这些项目的直接移植，该项目的成立基于这样的信念：下一波生成式 AI 应用将不仅面向 Python 开发人员，还将遍及多种编程语言。从本质上讲，Spring AI 解决了 AI 集成的基本挑战：Connecting your enterprise Data and APIs with the AI Models。
-
-
diff --git a/src/content/docs/ai/zh-cn/practices/playground-flight-booking.md b/src/content/docs/ai/zh-cn/practices/playground-flight-booking.md
deleted file mode 100644
index 84074b026..000000000
--- a/src/content/docs/ai/zh-cn/practices/playground-flight-booking.md
+++ /dev/null
@@ -1,109 +0,0 @@
----
-title: 智能机票助手
-keywords: [Spring AI,通义千问,百炼,智能体应用]
-description: "Spring AI 与通义千问集成，使用 Spring AI 开发 Java AI 应用。"
----
-> 本示例项目的源码请参 Github 仓库 [spring-ai-alibaba-examples](https://github.com/alibaba/spring-ai-alibaba/tree/main/spring-ai-alibaba-examples/playground-flight-booking)。
-
-接下来，我们通过一个更贴近实际使用场景的示例，来展示 Spring AI Alibaba 在构建智能体应用方面的强大能力。
-
-示例目标是使用 Spring AI Alibaba 框架开发一个智能机票助手，它可以帮助消费者完成<font style="color:#5e5e5e;">机票预定、问题解答、机票改签、取消等动作，具体要求为：</font>
-
-+ <font style="color:#5e5e5e;">基于 AI 大模型</font>与用户对话，理解用户自然语言表达的需求
-+ <font style="color:#5e5e5e;">支持多轮连续对话，能在上下文中理解用户意图</font>
-+ <font style="color:#5e5e5e;">理解机票操作相关的术语与规范并严格遵守，如航空法规、退改签规则等</font>
-+ 在必要时可<font style="color:#5e5e5e;">调用工具辅助完成任务</font>
-
-#### 完整架构图
-<font style="color:#5e5e5e;">基于这样一个</font>智能机票助手目标，我们绘制了一个如下图所示的架构图：
-
-![](/img/1728554016353.png)
-
-
-
-<font style="color:#5e5e5e;">接下来，我们结合架构图对示例进行详细分析。
-</font>
-
-#### <font style="color:#5e5e5e;">为应用接入 AI 模型服务</font>
-<font style="color:#5e5e5e;">本质上来说，我们是要用 Spring Boot 开发一个普通的 Java 应用，这个应用能够持续的接收用户的提问，为用户解决机票相关的问题，之所以叫它为智能体应用是因为我们这个应用可以与 AI 交互，由 AI 帮助应用理解用户问题并为用户做决策，所以对我们机票助手一个简化分解的架构图如下所示：</font>
-
-<font style="color:#5e5e5e;"></font>
-
-![](/img/1728554016631.png)
-
-<font style="color:#5e5e5e;"></font>
-
-#### <font style="color:#5e5e5e;">使用 RAG 增加机票退改签规则</font>
-<font style="color:#5e5e5e;">基于以上架构图，应用是由 AI 模型理解用户问题，决策下一步动作、驱动业务流程。但任何一个通用的大模型都能帮我们解决机票相关的问题吗？依赖模型的决策是可靠的吗？比如有用户提出了机票改签的诉求，模型一定是能够很好的理解用户的意图的，这点没有疑问。但它怎么知道当前用户符不符合退票规则那？要知道每个航空公司的改签规则可能都是不一样的；它怎么知道改签手续费的规定那？在这样一个可能带来经济纠纷、法律风险的应用场景下，AI模型必须要知道改签规则的所有细节，并逐条确认用户信息复合规则后，才能最终作出是否改签的决策。</font>
-
-<font style="color:#5e5e5e;">很显然，单纯依赖 AI 模型本身并不能替我们完成上面的要求，这个时候就要用到 RAG（检索增强）模式了。通过 RAG 我们可以把机票退改签相关的领域知识输入给应用和 AI 模型，让 AI 结合这些规则与要求辅助决策，增加 RAG 后的架构如下图所示：</font>
-
-
-
-![](/img/1728554016827.png)
-
-<font style="color:#5e5e5e;"></font>
-
-<font style="color:#5e5e5e;">有了 RAG 之后，我们的应用真正的成为了一个智能化的机票问题专家，就像一个经过公司业务培训的客服代表，既能人性化的与用户对话，又能根据规则引导用户行为。</font>
-
-<font style="color:#5e5e5e;"></font>
-
-#### <font style="color:#5e5e5e;">使用 Function Calling 执行业务动作</font>
-<font style="color:#5e5e5e;">AI 智能体可以帮助应用理解用户需求并作出决策，但是它没法代替应用完成决策的执行，决策的执行还是要由应用自己完成，这一点和传统应用并没有区别，不论是智能化的还是预先编排好的应用，都是要由应用本身去调用函数修改数据库记录实现数据持久化。</font>
-
-<font style="color:#5e5e5e;">通过 Spring AI 框架，我们可以将模型的决策转换为对某个具体函数的调用，从而完成机票的最终改签或者退票动作，将用户数据写入数据库，这就是我们前面提到的 Function Calling 模式。</font>
-
-<font style="color:#5e5e5e;"></font>
-
-![](/img/1728554017286.png)
-
-
-
-#### <font style="color:#5e5e5e;">使用 Chat Memory 增加多轮对话能力</font>
-<font style="color:#5e5e5e;">最后一点是关于多轮连续对话的支持，我们要记住一点，大模型是无状态的，它看到的只有当前这一轮对话的内容。因此如果要支持多轮对话效果，需要应用每次都要把之前的对话上下文保留下来，并与最新的问题一并作为 prompt 发送给模型。这时，我们可以利用 Spring AI Alibaba 提供的内置 Conversation Memory 支持，方便的维护对话上下文。</font>
-
-<font style="color:#5e5e5e;">总结起来，我们在这个智能机票助手应用中用到了 Spring AI Alibaba 的核心如下能力：</font>
-
-1. <font style="color:#5e5e5e;">基本模型对话能力，通过 Chat Model API 与阿里云通义模型交互</font>
-2. <font style="color:#5e5e5e;">Prompt 管理能力</font>
-3. <font style="color:#5e5e5e;">Chat Memory 聊天记忆，支持多轮对话</font>
-4. <font style="color:#5e5e5e;">RAG、Vector Store，机票预定、改签、退票等相关规则</font>
-
-
-![](/img/1728554017504.png)
-
-
-#### 使用 ChatClient 完成编码
-Spring AI Alibaba 不止提供了以上原子能力抽象，还提供了高阶 “智能体” API 抽象 `ChatClient`，让我们可以非常方便的使用流式 Fluent API 把多个组件组装起来，成为一个智能体 Agent。`ChatClient` 的使用方式如下：
-
-```java
-this.chatClient = modelBuilder
-				.defaultSystem("""
-						您是“Funnair”航空公司的客户聊天支持代理。请以友好、乐于助人且愉快的方式来回复。
-					   您正在通过在线聊天系统与客户互动。
-					   在提供有关预订或取消预订的信息之前，您必须始终
-					   从用户处获取以下信息：预订号、客户姓名。
-					   在询问用户之前，请检查消息历史记录以获取此信息。
-					   在更改预订之前，您必须确保条款允许这样做。
-					   如果更改需要收费，您必须在继续之前征得用户同意。
-					   使用提供的功能获取预订详细信息、更改预订和取消预订。
-					   如果需要，可以调用相应函数调用完成辅助动作。
-					   请讲中文。
-					   今天的日期是 {current_date}.
-					""")
-				.defaultAdvisors(
-						new PromptChatMemoryAdvisor(chatMemory), // Chat Memory
-						new VectorStoreChatMemoryAdvisor(vectorStore)),
-						new QuestionAnswerAdvisor(vectorStore, SearchRequest.defaults()), // RAG
-						new LoggingAdvisor())
-				.defaultFunctions("getBookingDetails", "changeBooking", "cancelBooking") // FUNCTION CALLING
-
-				.build();
-```
-
-<font style="color:#5e5e5e;">这样，</font>`<font style="color:#5e5e5e;">ChatClient</font>`<font style="color:#5e5e5e;">就为我们屏蔽了所有与大模型交互的细节，只需要把 </font>`<font style="color:#5e5e5e;">ChatClient</font>`<font style="color:#5e5e5e;">注入常规的 Spring Bean 就可以为我们的机票应用加入智能化能力了。</font>
-
-最终，我们开发的示例运行效果如下所示：
-
-![](/img/1728554017887.png)
-
diff --git a/src/content/docs/ai/zh-cn/practices/rag.md b/src/content/docs/ai/zh-cn/practices/rag.md
deleted file mode 100644
index 83ba558ba..000000000
--- a/src/content/docs/ai/zh-cn/practices/rag.md
+++ /dev/null
@@ -1,102 +0,0 @@
----
-title: RAG
-keywords: [Spring AI,通义千问,百炼,智能体应用]
-description: "Spring AI 与通义千问集成，使用 Spring AI 开发 Java AI 应用。"
----
-
-## RAG介绍
-检索增强生成 (RAG) 是一种使用来自私有或专有数据源的信息来辅助文本生成的技术。它将检索模型（设计用于搜索大型数据集或知识库）和生成模型（例如大型语言模型 (LLM)，此类模型会使用检索到的信息生成可供阅读的文本回复）结合在一起。
-
-通过从更多数据源添加背景信息，以及通过训练来补充 LLM 的原始知识库，检索增强生成能够提高搜索体验的相关性。这能够改善大型语言模型的输出，但又无需重新训练模型。额外信息源的范围很广，从训练 LLM 时并未用到的互联网上的新信息，到专有商业背景信息，或者属于企业的机密内部文档，都会包含在内。
-
-RAG 对于诸如回答问题和内容生成等任务，具有极大价值，因为它能支持生成式 AI 系统使用外部信息源生成更准确且更符合语境的回答。它会实施搜索检索方法（通常是语义搜索或混合搜索）来回应用户的意图并提供更相关的结果。
-
-下图是一个RAG链路的两个阶段，包括Indexing pipeline阶段和RAG的阶段。
-![img_1.png](/img/user/ai/tutorials/practices/rag_diagram.png)
-
-从上图可以看到, indexing pipeline的阶段主要是将结构化或者非结构化的数据或文档进行加载和解析、chunk切分、文本向量化并保存到向量数据库。
-RAG的阶段主要包括将prompt文本内容转为向量、从向量数据库检索内容、对检索后的文档chunk进行重排和prompt重写、最后调用大模型进行结果的生成。
-
-## RAG调用
-
-### 知识库内容导入
-下边是将pdf文档导入到知识库的代码
-
-```java
-DashScopeApi dashscopeApi = ...;
-
-// 1. 解析文档和chunk切分
-String filePath = "新能源产业有哪些-36氪.pdf";
-DashScopeDocumentCloudReader reader = new DashScopeDocumentCloudReader(filePath, dashscopeApi, null);
-List<Document> documentList = reader.get();
-DashScopeDocumentTransformer transformer = new DashScopeDocumentTransformer(dashscopeApi);
-List<Document> transformerList = transformer.apply(documentList);
-System.out.println(transformerList.size());
-
-// 2. 文档向量化
-DashScopeEmbeddingModel embeddingModel = new DashScopeEmbeddingModel(dashscopeApi);
-Document document = new Document("你好阿里云");
-float[] vectorList = embeddingModel.embed(document);
-
-// 3. 导入文档内容到向量存储
-DashScopeCloudStore cloudStore = new DashScopeCloudStore(dashscopeApi, new DashScopeStoreOptions("bailian-knowledge"));
-cloudStore.add(Arrays.asList(document));
-
-// 4. 删除文档
-cloudStore.delete(Arrays.asList(document.getId()));
-```
-
-### 知识问答
-
-下边代码将根据之前创建的知识库，进行知识问答的代码:
-```java
-DocumentRetriever retriever = new DashScopeDocumentRetriever(dashscopeApi, DashScopeDocumentRetrieverOptions.builder()
-                        .withIndexName("bailian-knowledge")
-                        .build());
-
-ChatClient chatClient = ChatClient.builder(dashscopeChatModel)
-                .defaultAdvisors(new DocumentRetrievalAdvisor(retriever))
-                .build();
-
-ChatResponse response = chatClient
-                .prompt()
-                .user("如何快速开始百炼?")
-                .call()
-                .chatResponse();
-String content = response.getResult().getOutput().getContent();
-Assertions.assertNotNull(content);
-
-logger.info("content: {}", content);
-```
-
-如果需要返回检索召回后，模型采纳和引用的文档内容, 可以通过以下代码实现:
-```java
-DocumentRetriever retriever = new DashScopeDocumentRetriever(dashscopeApi,
-                DashScopeDocumentRetrieverOptions.builder()
-                        .withIndexName("spring-ai知识库")
-                        .build());
-
-ChatClient chatClient = ChatClient.builder(dashscopeChatModel)
-                .defaultAdvisors(new DashScopeDocumentRetrievalAdvisor(retriever, true))
-                .build();
-
-ChatResponse response = chatClient
-                .prompt()
-                .user("如何快速开始百炼?")
-                .call()
-                .chatResponse();
-
-String content = response.getResult().getOutput().getContent();
-Assertions.assertNotNull(content);
-logger.info("content: {}", content);
-
-//获取引用的内容
-List<Document> documents = (List<Document>) response.getMetadata().get(DashScopeDocumentRetrievalAdvisor.RETRIEVED_DOCUMENTS);
-Assertions.assertNotNull(documents);
-
-for (Document document : documents) {
-            logger.info("referenced doc name: {}, title: {}, score: {}", document.getMetadata().get("doc_name"),
-                    document.getMetadata().get("title"), document.getMetadata().get("_score"));
-        }
-
-```
\ No newline at end of file
diff --git a/src/content/docs/ai/zh-cn/tutorials/chat-client.md b/src/content/docs/ai/zh-cn/tutorials/chat-client.md
deleted file mode 100644
index 636d36413..000000000
--- a/src/content/docs/ai/zh-cn/tutorials/chat-client.md
+++ /dev/null
@@ -1,422 +0,0 @@
----
-title: Chat Client
-keywords: [Spring AI,通义千问,百炼,智能体应用]
-description: "Spring AI 与通义千问集成，使用 Spring AI 开发 Java AI 应用。"
----
-
-## ChatClient 简介
-
-`ChatClient` 提供了与 AI 模型通信的 Fluent API，它支持同步和反应式（Reactive）编程模型。与 `ChatModel`、`Message`、`ChatMemory` 等原子 API 相比，使用 `ChatClient` 可以将与 LLM 及其他组件交互的复杂性隐藏在背后，因为基于 LLM 的应用程序通常要多个组件协同工作（例如，提示词模板、聊天记忆、LLM Model、输出解析器、RAG 组件：嵌入模型和存储），并且通常涉及多个交互，因此协调它们会让编码变得繁琐。当然使用 `ChatModel` 等原子 API 可以为应用程序带来更多的灵活性，成本就是您需要编写大量样板代码。
-
-ChatClient 类似于应用程序开发中的服务层，它为应用程序直接提供 `AI 服务`，开发者可以使用 ChatClient Fluent API 快速完成一整套 AI 交互流程的组装。
-
-包括一些基础功能，如：
-* 定制和组装模型的输入（Prompt）
-* 格式化解析模型的输出（Structured Output）
-* 调整模型交互参数（ChatOptions）
-
-还支持更多高级功能：
-* 聊天记忆（Chat Memory）
-* 工具/函数调用（Function Calling）
-* RAG
-
-
-## 创建 ChatClient
-
-使用 `ChatClient.Builder` 对象创建 `ChatClient` 实例，您可以自动注入由Spring Boot 自动配置创建的默认 `ChatClient.Builder` 实例，您也可以通过编程方式自行创建一个 `ChatClient.Builder` 实例并用它来得到 `ChatClient` 实例。
-
-### 使用自动配置的 ChatClient.Builder
-
-在快速开始示例中，就是使用的 Spring Boot 自动装配默认生成的 `ChatClient.Builder` 的 bean，把它注入到您自己的类中。这里是根据用户提问并从模型得到文本回答的简单例子：
-
-```java
-    @RestController
-    public class ChatController {
-
-    	private final ChatClient chatClient;
-
-    	public ChatController(ChatClient.Builder builder) {
-    		this.chatClient = builder.build();
-    	}
-
-    	@GetMapping("/chat")
-    	public String chat(String input) {
-    		return this.chatClient.prompt()
-    				.user(input)
-    				.call()
-    				.content();
-    	}
-    }
-```
-
-在这个示例中，首先设置了用户消息的内容，call 方法向 AI 模型发送请求，content 方法以字符串形式返回 AI 模型的响应。
-
-### 以编程方式创建 ChatClient
-
-您可以通过设置属性 `spring.ai.chat.client.enabled=false` 来禁用 `ChatClient.Builder` bean 的自动配置，如果需要多个聊天模型一起使用，这会很有用，然后以编程方式创建 `ChatClient.Builder`，这样可以为每个聊天模型创建一个实例 `ChatModel`：
-
-```java
-    ChatModel myChatModel = ... // usually autowired
-
-    ChatClient.Builder builder = ChatClient.builder(myChatModel);
-
-    // or create a ChatClient with the default builder settings:
-
-    ChatClient chatClient = ChatClient.create(myChatModel);
-```
-
-## 处理 ChatClient 响应
-
-ChatClient API 提供了多种方法格式化来自 AI 模型的响应。
-
-### 返回 ChatResponse
-
-AI 模型的响应是一种由 [ChatResponse](https://docs.spring.io/spring-ai/reference/api/chatmodel.html#ChatResponse)类型定义的丰富结构。响应类型中包含模型生成的相关元数据信息，同时它还可以包含多个子响应（称为 [Generation](https://docs.spring.io/spring-ai/reference/api/chatmodel.html#Generation)），每个子响应都有自己的元数据。元数据包括用于创建响应的令牌（token）数量信息（在英文中，每个令牌大约为一个单词的 3/4），了解令牌信息很重要，因为 AI 模型根据每个请求使用的令牌数量收费。
-
-下面的代码段显示了通过调用 `chatResponse()` 返回 `ChatResponse` 的示例，相比于调用 `content()` 方法，这里在调用 `call()` 方法之后调用 `chatResponse()`。
-
-```java
-    ChatResponse chatResponse = chatClient.prompt()
-        .user("Tell me a joke")
-        .call()
-        .chatResponse();
-````
-
-### 返回实体类（Entity）
-
-如果您希望应用接口返回一个预先定义好的实体类型（即完成实体 Bean 的映射），Spring AI Alibaba 框架也提供了将模型响应映射到 Java Bean 的转换，您可以在模型的 call() 方法之后调用`entity()` 实现。
-
-例如，给定 Java record（POJO）定义：
-
-```java
-    record ActorFilms(String actor, List<String> movies) {
-    }
-```
-
-您可以使用该 `entity` 方法轻松地将 AI 模型的输出映射到 ActorFilms 类型，如下所示：
-
-```java
-    ActorFilms actorFilms = chatClient.prompt()
-        .user("Generate the filmography for a random actor.")
-        .call()
-        .entity(ActorFilms.class);
-```
-
-`entity` 还有一种带有参数的重载方法 `entity(ParameterizedTypeReference<T> type)`，可让您指定如泛型 List 等类型：
-
-```java
-    List<ActorFilms> actorFilms = chatClient.prompt()
-        .user("Generate the filmography of 5 movies for Tom Hanks and Bill Murray.")
-        .call()
-        .entity(new ParameterizedTypeReference<List<ActorFilms>>() {
-        });
-```
-
-### 流式响应
-
-`stream` 方法是一种异步的、持续获得模型响应的方式：
-
-```java
-    Flux<String> output = chatClient.prompt()
-        .user("Tell me a joke")
-        .stream()
-        .content();
-```
-
-相比于上面的 `Flux<String>`，您还可以使用 `Flux<ChatResponse> chatResponse()` 方法获得 `ChatResponse` 响应数据流。
-
-## call() 返回值
-
-`ChatClient.call()` 方法支持几种不同类型的响应格式。
-
-*   `String content()`：返回响应的字符串内容
-*   `ChatResponse chatResponse()`：返回`ChatResponse`包含多个 Generation 以及有关响应的元数据的对象。例如，使用了多少个令牌来创建响应。
-*   `entity` 返回 Java 类型
-    *   entity(ParameterizedTypeReference<T> type)：用于返回实体类型的集合。
-    *   entity(Class<T> type): 用于返回特定的实体类型。
-    *   entity(StructuredOutputConverter<T> structuredOutputConverter): 用于指定一个实例 `StructuredOutputConverter`，将 `String` 转换为实体类型。
-
-## stream() 返回值
-
-您还可以调用 `stream()` 方法来获得模型的响应，而不是只使用 `call()` 方法，`strem()` 方法的响应类型有以下几种选项：
-
-*   `Flux<String> content()`：返回由 AI 模型生成的 `Flux<String>` 对象。
-*   `Flux<ChatResponse> chatResponse()`：返回 `Flux<ChatResponse>` 对象，其中包含模型相应的元数据和其他信息。
-
-## 自定义 ChatClient 默认值
-
-在前面 ChatClient 的初步体验中，我们使用 `ChatClient.Builder.build()` 快速创建了一个 ChatClient 实例，**开发者还可以使用 `ChatClient.Builder` 来自定义 ChatClient 实例的相关属性**。
-
-注意：**创建 ChatClient 时指定的配置将作为与模型交互时的默认参数，这样可以避免每次调用都重复设置**。
-
-### 设置默认 System Message
-
-在以下示例中，我们为 ChatClient 设置了一个默认的 system message（以海盗风格回答所有问题）。当 ChatClient 与模型交互时都会自动携带这条 system message，用户只需要指定 user message 即可。
-
-```java
-@Configuration
-class Config {
-
-    @Bean
-    ChatClient chatClient(ChatClient.Builder builder) {
-        return builder.defaultSystem("You are a friendly chat bot that answers question in the voice of a Pirate")
-                .build();
-    }
-
-}
-```
-
-在 Controller 中使用自定义的 ChatClient 实例：
-
-```java
-@RestController
-class AIController {
-
-    private final ChatClient chatClient;
-
-    AIController(ChatClient chatClient) {
-        this.chatClient = chatClient;
-    }
-
-    @GetMapping("/ai/simple")
-    public Map<String, String> completion(@RequestParam(value = "message", defaultValue = "Tell me a joke") String message) {
-        return Map.of("completion", chatClient.prompt().user(message).call().content());
-    }
-}
-```
-
-启动示例，通过 curl 测试效果：
-
-```shell
-> curl localhost:8080/ai/simple
-
-{"generation":"Why did the pirate go to the comedy club? To hear some arrr-rated jokes! Arrr, matey!"}
-```
-
-在上面 `builder.defaultSystem()` 创建 ChatClient 时。我们还可以选择使用 Prompt 模板，类似 "You are a friendly chat bot that answers question in the voice of a {voice}"，这让我们有机会在每次调用前修改请求参数。
-
-```java
-@Configuration
-class Config {
-
-    @Bean
-    ChatClient chatClient(ChatClient.Builder builder) {
-        return builder.defaultSystem("You are a friendly chat bot that answers question in the voice of a {voice}")
-                .build();
-    }
-
-}
-
-@RestController
-class AIController {
-    private final ChatClient chatClient
-    AIController(ChatClient chatClient) {
-        this.chatClient = chatClient;
-    }
-    @GetMapping("/ai")
-    Map<String, String> completion(@RequestParam(value = "message", defaultValue = "Tell me a joke") String message, String voice) {
-        return Map.of(
-                "completion",
-                chatClient.prompt()
-                        .system(sp -> sp.param("voice", voice))
-                        .user(message)
-                        .call()
-                        .content());
-    }
-}
-```
-
-答案是：
-
-```shell
-http localhost:8080/ai voice=='Robert DeNiro'
-
-{
-    "completion": "You talkin' to me? Okay, here's a joke for ya: Why couldn't the bicycle stand up by itself? Because it was two tired! Classic, right?"
-}
-```
-
-### 其他默认设置
-
-除了 `defaultSystem` 之外，您还可以在 `ChatClient.Builder` 中指定其他默认提示词。
-
-*   `defaultOptions(ChatOptions chatOptions)`：传入 `ChatOptions` 类中定义的可移植选项或特定于模型实现的如 `DashScopeChatOptions` 选项。有关特定于模型的`ChatOptions`实现的更多信息，请参阅 JavaDocs。
-
-*   `defaultFunction(String name, String description, java.util.function.Function<I, O> function)`：`name` 用于在用户文本中引用该函数，`description`解释该函数的用途并帮助 AI 模型选择正确的函数以获得准确的响应，参数 `function` 是模型将在必要时执行的 Java 函数实例。
-
-*   `defaultFunctions(String... functionNames)`：应用程序上下文中定义的 java.util.Function 的 bean 名称。
-
-*   `defaultUser(String text)`、`defaultUser(Resource text)`、`defaultUser(Consumer<UserSpec> userSpecConsumer)` 这些方法允许您定义用户消息输入，`Consumer<UserSpec>`允许您使用 lambda 指定用户消息输入和任何默认参数。
-
-*   `defaultAdvisors(RequestResponseAdvisor... advisor)`：Advisors 允许修改用于创建 `Prompt` 的数据，`QuestionAnswerAdvisor` 实现通过在 Prompt 中附加与用户文本相关的上下文信息来实现 `Retrieval Augmented Generation` 模式。
-
-*   `defaultAdvisors(Consumer<AdvisorSpec> advisorSpecConsumer)`：此方法允许您定义一个 `Consumer` 并使用 `AdvisorSpec` 配置多个 Advisor，Advisor 可以修改用于创建 `Prompt` 的最终数据，`Consumer<AdvisorSpec>` 允许您指定 lambda 来添加 Advisor 例如 `QuestionAnswerAdvisor`。
-
-您可以在运行时使用 `ChatClient` 提供的不带 `default` 前缀的相应方法覆盖这些默认值。
-
-*   `options(ChatOptions chatOptions)`
-
-*   `function(String name, String description, java.util.function.Function<I, O> function)`
-
-*   `functions(String... functionNames)`
-
-*   `user(String text)`、`user(Resource text)`、`user(Consumer<UserSpec> userSpecConsumer)`
-
-*   `advisors(RequestResponseAdvisor... advisor)`
-
-*   `advisors(Consumer<AdvisorSpec> advisorSpecConsumer)`
-
-
-## Advisors
-
-在使用用户输入文本构建 Prompt 调用 AI 模型时。一个常见模式是使用上下文数据附加或扩充 Prompt，最终使用扩充后的 Prompt 与模型交互。
-
-这些用于扩充 Prompt 的上下文数据可以是不同类型的，常见类型包括：
-
-* **您自己的数据**：这是 AI 模型尚未训练过的数据，如特定领域知识、产品文档等，即使模型已经看到过类似的数据，附加的上下文数据也会优先生成响应。
-* **对话历史记录**：聊天模型的 API 是无状态的，如果您告诉 AI 模型您的姓名，它不会在后续交互中记住它，每次请求都必须发送对话历史记录，以确保在生成响应时考虑到先前的交互。
-
-### 检索增强生成（RAG）
-
-向量数据库存储的是 AI 模型不知道的数据，当用户问题被发送到 AI 模型时，`QuestionAnswerAdvisor`  会在向量数据库中查询与用户问题相关的文档。
-
-来自向量数据库的响应被附加到用户消息 Prompt 中，为 AI 模型生成响应提供上下文。
-
-假设您已将数据加载到中 `VectorStore`，则可以通过向 `ChatClient` 提供 `QuestionAnswerAdvisor` 实例来执行检索增强生成 (RAG ) 。
-
-```java
-ChatResponse response = ChatClient.builder(chatModel)
-        .build().prompt()
-        .advisors(new QuestionAnswerAdvisor(vectorStore, SearchRequest.defaults()))
-        .user(userText)
-        .call()
-        .chatResponse();
-```
-
-在此示例中，`SearchRequest.defaults()` 将对 Vector 向量数据库中的所有文档执行相似性搜索。为了限制要搜索的文档类型，`SearchRequest` 采用了可移植到任意向量数据库中的类似 SQL 筛选表达式。
-
-#### 动态过滤表达式
-
-`SearchRequest` 使用 `FILTER_EXPRESSION` Advisor 上下文参数在运行时更新过滤表达式：
-
-```java
-ChatClient chatClient = ChatClient.builder(chatModel)
-    .defaultAdvisors(new QuestionAnswerAdvisor(vectorStore, SearchRequest.defaults()))
-    .build();
-
-// Update filter expression at runtime
-String content = chatClient.prompt()
-    .user("Please answer my question XYZ")
-    .advisors(a -> a.param(QuestionAnswerAdvisor.FILTER_EXPRESSION, "type == 'Spring'"))
-    .call()
-    .content();
-```
-
-该 `FILTER_EXPRESSION` 参数允许您根据提供的表达式动态过滤搜索结果。
-
-### 聊天记忆
-
-`ChatMemory` 接口表示聊天对话历史记录的存储，它提供向对话添加消息、从对话中检索消息以及清除对话历史记录的方法。
-
-目前提供两种实现方式 `InMemoryChatMemory`、`CassandraChatMemory`，分别为聊天对话历史记录提供内存存储和 `time-to-live` 类型的持久存储。
-
-创建一个包含 `time-to-live` 配置的 `CassandraChatMemory`
-
-```java
-    CassandraChatMemory.create(CassandraChatMemoryConfig.builder().withTimeToLive(Duration.ofDays(1)).build());
-```
-
-以下 Advisor 实现使用 `ChatMemory` 接口来使用对话历史记录来增强（advice）Prompt，这些 advisor 实现在如何将对话历史记录添加到 Prompt 的细节上有所不同。
-
-*   `MessageChatMemoryAdvisor`：内存被检索并作为消息集合添加到提示中
-*   `PromptChatMemoryAdvisor`：检索内存并将其添加到提示的系统文本中。
-*   `VectorStoreChatMemoryAdvisor` ：构造函数`VectorStoreChatMemoryAdvisor(VectorStore vectorStore, String defaultConversationId, int chatHistoryWindowSize)`允许您指定要从中检索聊天历史记录的 VectorStore、唯一的对话 ID、要检索的聊天历史记录的大小（以令牌大小为单位）。
-
-
-下面的 `@Service` 提供了一个使用多个 Advisor 的示例实现：
-
-```java
-import static org.springframework.ai.chat.client.advisor.AbstractChatMemoryAdvisor.CHAT_MEMORY_CONVERSATION_ID_KEY;
-import static org.springframework.ai.chat.client.advisor.AbstractChatMemoryAdvisor.CHAT_MEMORY_RETRIEVE_SIZE_KEY;
-
-@Service
-public class CustomerSupportAssistant {
-
-    private final ChatClient chatClient;
-
-    public CustomerSupportAssistant(ChatClient.Builder builder, VectorStore vectorStore, ChatMemory chatMemory) {
-
-    this.chatClient = builder
-            .defaultSystem("""
-                    You are a customer chat support agent of an airline named "Funnair".", Respond in a friendly,
-                    helpful, and joyful manner.
-
-                    Before providing information about a booking or cancelling a booking, you MUST always
-                    get the following information from the user: booking number, customer first name and last name.
-
-                    Before changing a booking you MUST ensure it is permitted by the terms.
-
-                    If there is a charge for the change, you MUST ask the user to consent before proceeding.
-                    """)
-            .defaultAdvisors(
-                    new PromptChatMemoryAdvisor(chatMemory),
-                    // new MessageChatMemoryAdvisor(chatMemory), // CHAT MEMORY
-                    new QuestionAnswerAdvisor(vectorStore, SearchRequest.defaults()),
-                    new LoggingAdvisor()) // RAG
-            .defaultFunctions("getBookingDetails", "changeBooking", "cancelBooking") // FUNCTION CALLING
-            .build();
-}
-
-public Flux<String> chat(String chatId, String userMessageContent) {
-
-    return this.chatClient.prompt()
-            .user(userMessageContent)
-            .advisors(a -> a
-                    .param(CHAT_MEMORY_CONVERSATION_ID_KEY, chatId)
-                    .param(CHAT_MEMORY_RETRIEVE_SIZE_KEY, 100))
-            .stream().content();
-    }
-}
-```
-
-### 日志记录
-
- `SimpleLoggerAdvisor` 是一个用于记录 ChatClient 的 `request` 和 `response` 数据 Advisor，这对于调试和监控您的 AI 交互非常有用。
-
-要启用日志记录，请在创建 ChatClient 时将 `SimpleLoggerAdvisor` 添加到 Advisor 链中。建议将其添加到链的末尾：
-
-```java
-ChatResponse response = ChatClient.create(chatModel).prompt()
-        .advisors(new SimpleLoggerAdvisor())
-        .user("Tell me a joke?")
-        .call()
-        .chatResponse();
-```
-
-要查看日志，请将 Advisor 包的日志记录级别设置为 `DEBUG`：
-
-```properties
-org.springframework.ai.chat.client.advisor=DEBUG
-```
-
-将其添加到您的 `application.properties` 或 `application.yaml` 文件中。
-
-您可以使用以下构造函数自定义如何使用 `SimpleLoggerAdvisor` 记录来自 AdvisedRequest 和 ChatResponse 的数据：
-
-```java
-SimpleLoggerAdvisor(
-    Function<AdvisedRequest, String> requestToString,
-    Function<ChatResponse, String> responseToString
-)
-```
-
-使用示例：
-
-```java
-javaCopySimpleLoggerAdvisor customLogger = new SimpleLoggerAdvisor(
-    request -> "Custom request: " + request.userText,
-    response -> "Custom response: " + response.getResult()
-);
-```
-
-这使得您可以根据您的特定需求定制需要记录的信息。
diff --git a/src/content/docs/ai/zh-cn/tutorials/chat-model.md b/src/content/docs/ai/zh-cn/tutorials/chat-model.md
deleted file mode 100644
index c0f324ee4..000000000
--- a/src/content/docs/ai/zh-cn/tutorials/chat-model.md
+++ /dev/null
@@ -1,98 +0,0 @@
----
-title: 对话模型(Chat Model)
-keywords: [Spring AI,通义千问,百炼,智能体应用]
-description: "Spring AI 与通义千问集成，使用 Spring AI 开发 Java AI 应用。"
----
-
-对话模型（Chat Model）接收一系列消息（Message）作为输入，与模型 LLM 服务进行交互，并接收返回的聊天消息（Chat Message）作为输出。相比于普通的程序输入，模型的输入与输出消息（Message）不止支持纯字符文本，还支持包括语音、图片、视频等作为输入输出。同时，在 Spring AI Alibaba 中，消息中还支持包含不同的角色，帮助底层模型区分来自模型、用户和系统指令等的不同消息。
-
-Spring AI Alibaba 复用了 Spring AI 抽象的 Model API，并与通义系列大模型服务进行适配（如通义千问、通义万相等），目前支持纯文本聊天、文生图、文生语音、语音转文本等。以下是框架定义的几个核心 API：
-* ChatModel，文本聊天交互模型，支持纯文本格式作为输入，并将模型的输出以格式化文本形式返回。
-* ImageModel，接收用户文本输入，并将模型生成的图片作为输出返回。
-* AudioModel，接收用户文本输入，并将模型合成的语音作为输出返回。
-
-Spring AI Alibaba 支持以上 Model 抽象与通义系列模型的适配，并通过 `spring-ai-alibaba-starter` AutoConfiguration 自动初始化了默认实例，因此我们可以在应用程序中直接注入 ChatModel、ImageModel 等 bean，当然在需要的时候也可以自定义 Model 实例。
-
-## Chat Model
-
-ChatModel API 让应用开发者可以非常方便的与 AI 模型进行文本交互，它抽象了应用与模型交互的过程，包括使用 `Prompt` 作为输入，使用 `ChatResponse` 作为输出等。ChatModel 的工作原理是接收 Prompt 或部分对话作为输入，将输入发送给后端大模型，模型根据其训练数据和对自然语言的理解生成对话响应，应用程序可以将响应呈现给用户或用于进一步处理。
-
-![chat-model](https://img.alicdn.com/imgextra/i2/O1CN01wyTDFO1kR2BJOn3fe_!!6000000004679-0-tps-2555-1565.jpg)
-
-### 使用示例
-开发完整的 ChatModel 示例应用，您需要添加 `spring-ai-alibaba-starter` 依赖，请参考快速开始中的项目配置说明了解详情，您还可以访问 [chatmodel-example](https://github.com/alibaba/spring-ai-alibaba/tree/main/spring-ai-alibaba-examples/chatmodel-example) 查看本示例完整源码。
-
-以下是 ChatModel 基本使用示例，它可以接收 String 字符串作为输入：
-
-```java
-@RestController
-public class ChatModelController {
-	private final ChatModel chatModel;
-
-	public ChatModelController(ChatModel chatModel) {
-		this.chatModel = chatModel;
-	}
-
-	@RequestMapping("/chat")
-	public String chat(String input) {
-		ChatResponse response = chatModel.call(new Prompt(input));
-		return response.getResult().getOutput().getContent();
-	}
-}
-```
-
-使用 Prompt 作为输入：
-```java
-
-```
-
-Streaming 示例：
-```java
-
-```
-
-通过 ChatOptions 在每次调用中调整模型参数：
-```java
-
-```
-
-## Image Model
-ImageModel API 抽象了应用程序通过模型调用实现“文生图”的交互过程，即应用程序接收文本，调用模型生成图片。ImageModel 的入参为包装类型 `ImagePrompt`，输出类型为 `ImageResponse`。
-
-### 使用示例
-
-`spring-ai-alibaba-starter` AutoConfiguration 默认初始化了 ImageModel 实例，我们可以选择直接注入并使用默认实例。
-
-```java
-@RestController
-public class ImageModelController {
-	private final ImageModel imageModel;
-
-	ImageModelController(ImageModel imageModel) {
-		this.imageModel = imageModel;
-	}
-
-	@RequestMapping("/image")
-	public String image(String input) {
-		ImageOptions options = ImageOptionsBuilder.builder()
-				.withModel("dall-e-3")
-				.build();
-
-		ImagePrompt imagePrompt = new ImagePrompt(input, options);
-		ImageResponse response = imageModel.call(imagePrompt);
-		String imageUrl = response.getResult().getOutput().getUrl();
-
-		return "redirect:" + imageUrl;
-	}
-}
-```
-
-通过 ImageOptions 在每次调用中调整模型参数：
-```java
-
-```
-
-## Audio Model
-当前，Spring AI Alibaba 支持以下两种通义语音模型的适配，分别是：
-1. 文本生成语音 SpeechModel，对应于 OpenAI 的 Text-To-Speech (TTS) API
-2. 录音文件生成文字 DashScopeAudioTranscriptionModel，对应于 OpenAI 的 Transcription API
diff --git a/src/content/docs/ai/zh-cn/tutorials/embedding.md b/src/content/docs/ai/zh-cn/tutorials/embedding.md
deleted file mode 100644
index 4b4200c13..000000000
--- a/src/content/docs/ai/zh-cn/tutorials/embedding.md
+++ /dev/null
@@ -1,217 +0,0 @@
----
-title: 嵌入模型 (Embedding Model)
-keywords: [Spring AI,通义千问,百炼,智能体应用]
-description: "Spring AI 与通义千问集成，使用 Spring AI 开发 Java AI 应用。"
----
-
-## 核心概念
-嵌入(`Embedding`)的工作原理是将文本、图像和视频转换为称为向量（Vectors）的浮点数数组。这些向量旨在捕捉文本、图像和视频的含义。嵌入数组的长度称为向量的维度（Dimensionality）。
-
-嵌入模型（`EmbeddingModel`）是嵌入过程中采用的模型。当前EmbeddingModel的接口主要用于将文本转换为数值向量，接口的设计主要围绕这两个目标展开：
-- 可移植性：该接口确保在各种嵌入模型之间的轻松适配。它允许开发者在不同的嵌入技术或模型之间切换，所需的代码更改最小化。这一设计与 Spring 模块化和互换性的理念一致。 
-- 简单性：嵌入模型简化了文本转换为嵌入的过程。通过提供如`embed(String text)`和`embed(Document document)`这样简单的方法，它去除了处理原始文本数据和嵌入算法的复杂性。这个设计选择使开发者，尤其是那些初次接触 AI 的开发者，更容易在他们的应用程序中使用嵌入，而无需深入了解其底层机制。
-
-## API介绍
-### EmbeddingModel
-本节介绍`EmbeddingModel`的接口和类。
-```java
-public interface EmbeddingModel extends Model<EmbeddingRequest, EmbeddingResponse> {
-
-    @Override
-    EmbeddingResponse call(EmbeddingRequest request);
-
-    /**
-     * Embeds the given document's content into a vector.
-     * @param document the document to embed.
-     * @return the embedded vector.
-     */
-    List<Double> embed(Document document);
-
-    /**
-     * Embeds the given text into a vector.
-     * @param text the text to embed.
-     * @return the embedded vector.
-     */
-    default List<Double> embed(String text) {
-        Assert.notNull(text, "Text must not be null");
-        return this.embed(List.of(text)).iterator().next();
-    }
-
-    /**
-     * Embeds a batch of texts into vectors.
-     * @param texts list of texts to embed.
-     * @return list of list of embedded vectors.
-     */
-    default List<List<Double>> embed(List<String> texts) {
-        Assert.notNull(texts, "Texts must not be null");
-        return this.call(new EmbeddingRequest(texts, EmbeddingOptions.EMPTY))
-                .getResults()
-                .stream()
-                .map(Embedding::getOutput)
-                .toList();
-    }
-
-    /**
-     * Embeds a batch of texts into vectors and returns the {@link EmbeddingResponse}.
-     * @param texts list of texts to embed.
-     * @return the embedding response.
-     */
-    default EmbeddingResponse embedForResponse(List<String> texts) {
-        Assert.notNull(texts, "Texts must not be null");
-        return this.call(new EmbeddingRequest(texts, EmbeddingOptions.EMPTY));
-    }
-
-    /**
-     * @return the number of dimensions of the embedded vectors. It is generative
-     * specific.
-     */
-    default int dimensions() {
-        return embed("Test String").size();
-    }
-
-}
-```
-Embedding Model API提供多种选项，将文本转换为Embeddings，支持单个字符串、结构化的Document对象或文本批处理。
-
-有多种快捷方式可以获得文本Embeddings。例如`embed(String text)`方法，它接受单个字符串并返回相应的 Embedding 向量。所有方法都围绕着`call`方法实现，这是调用 Embedding Model的主要方法。
-
-通常，Embedding返回一个float数组，以数值向量格式表示Embeddings。
-
-`embedForResponse`方法提供了更全面的输出，可能包括有关Embeddings的其他信息。
-
-`dimensions`方法是开发人员快速确定 Embedding 向量大小的便利工具，这对于理解 Embedding space 和后续处理步骤非常重要。
-#### EmbeddingRequest
-`EmbeddingRequest`是一种`ModelRequest`，它接受文本对象列表和可选的Embedding请求选项。以下代码片段简要地显示了 EmbeddingRequest 类，省略了构造函数和其他工具方法：
-```java
-public class EmbeddingRequest implements ModelRequest<List<String>> {
-private final List<String> inputs;
-private final EmbeddingOptions options;
-// other methods omitted
-}
-```
-
-#### EmbeddingResponse
-`EmbeddingResponse`类的结构如下：
-```java
-public class EmbeddingResponse implements ModelResponse<Embedding> {
-    private List<Embedding> embeddings;
-    private EmbeddingResponseMetadata metadata = new EmbeddingResponseMetadata();
-    // other methods omitted
-}
-```
-`EmbeddingResponse`类保存了AI模型的输出，其中每个 Embedding 实例包含来自单个文本输入的结果向量数据。同时，它还携带了有关 AI 模型响应的`EmbeddingResponseMetadata`元数据。
-#### Embedding
-`Embedding`表示一个 Embedding 向量。
-```java
-public class Embedding implements ModelResult<List<Double>> {
-    private List<Double> embedding;
-    private Integer index;
-    private EmbeddingResultMetadata metadata;
-// other methods omitted
-}
-```
-## 示例用法
-Spring AI Alibaba已经集成了`阿里云百炼平台`，接下来介绍基于阿里云百炼平台调用Embedding Model API。
-### 准备工作
-在开始之前，参考如下链接获取API-KEY：[获取API-KEY](https://help.aliyun.com/zh/model-studio/developer-reference/get-api-key)。
-然后，在项目环境中设置API-KEY，有两种方式：
-
-- 方式一：设置`configuration properties：spring.ai.dashscope.api-key` 为上述API-KEY。
-- 方式二：设置环境变量`export SPRING_AI_DASHSCOPE_API_KEY=<YOUR API  KEY>`
-
-### Auto-configuration
-Spring AI 为 DashScope Embedding Model提供了 Spring Boot 的自动配置。要启用此功能，请将以下依赖项添加到您项目的 Maven`pom.xml`文件中：
-```xml
-<dependency>
-    <groupId>org.springframework.ai</groupId>
-    <artifactId>spring-ai-dashscope-spring-boot-starter</artifactId>
-</dependency>
-```
-或者添加到您的Gradle`build.gradle`文件中：
-```gradle
-dependencies {
-    implementation 'org.springframework.ai:spring-ai-dashscope-spring-boot-starter'
-}
-```
-#### Embedding Properties
-前缀`spring.ai.dashscope`是用于配置连接至 DashScope 的属性前缀。
-
-| Property                       | Action          | Default |
-|:-------------------------------|:----------------|---------|
-| `spring.ai.dashscope.api-key`  | 来自百炼平台的API KEY  | -       |
-
-
-```tips
-所有以 spring.ai.dashscope 开头的属性都可以在运行过程中通过在 EmbeddingRequest 调用中添加特定请求的Runtime Options来覆盖。
-```
-
-### Runtime Options
-`DashScopeEmbeddingOptions`提供了Embedding Request的配置信息，它提供了一个构建器，用于创建选项。
-
-在启动时，可以使用`DashScopeEmbeddingModel`构造函数设置所有嵌入请求使用的默认选项。在运行时，可以通过将一个`DashScopeEmbeddingOptions`实例传递给`EmbeddingRequest`请求来覆盖默认选项。
-
-例如，使用指定的请求覆盖默认的模型名称：
-```java
-EmbeddingResponse embeddingResponse = embeddingModel.call(
-        new EmbeddingRequest(List.of("Hello World", "World is big and salvation is near"),
-                DashScopeEmbeddingOptions.builder()
-                        .withModel("Different-Embedding-Model-Deployment-Name")
-                        .build()));
-```
-
-### 示例代码
-该示例将创建一个`EmbeddingModel`实例，您可以将其注入到您的类中。以下是一个简单的`@Controller`类的示例，它使用了该 EmbeddingModel 实例。
-```properties
-spring.ai.dashscope.api-key=YOUR_API_KEY
-```
-
-```java
-@RestController
-public class EmbeddingController {
-
-    private final EmbeddingModel embeddingModel;
-
-    @Autowired
-    public EmbeddingController(EmbeddingModel embeddingModel) {
-        this.embeddingModel = embeddingModel;
-    }
-
-    @GetMapping("/ai/embedding")
-    public Map embed(@RequestParam(value = "message", defaultValue = "Tell me a joke") String message) {
-        EmbeddingResponse embeddingResponse = this.embeddingModel.embedForResponse(List.of(message));
-        return Map.of("embedding", embeddingResponse);
-    }
-}
-```
-
-### Manual Configuration
-如果您不希望使用 Spring Boot 的 Auto-configuration，可以在应用程序中手动配置`DashScopeEmbeddingModel`。为此，请将`spring.ai.dashscope`依赖项添加到您项目的 Maven`pom.xml`文件中：
-```xml
-<dependency>
-    <groupId>org.springframework.ai</groupId>
-    <artifactId>spring-ai-dashscope</artifactId>
-</dependency>
-```
-
-或者添加到您的Gradle`build.gradle`文件中：
-```gradle
-dependencies {
-    implementation 'org.springframework.ai:spring-ai-dashscope'
-}
-```
-
-```note
-spring-ai-dashcope 依赖项还提供了对 DashScopeChatModel 的访问。有关 DashScopeChatModel 的更多信息，请参考 DashScope Chat Client部分。
-```
-
-接下来，创建一个`DashScopeEmbeddingModel`实例，并使用它计算两个输入文本之间的相似性：
-```java
-var dashScopeApi = new DashScopeApi(System.getenv("DASHSCOPE_API_KEY"));
-var embeddingModel = new DashScopeEmbeddingModel(dashScopeApi, MetadataMode.EMBED,
-        DashScopeEmbeddingOptions.builder()
-                .withModel("text-embedding-v2")
-                .build());
-
-EmbeddingResponse embeddingResponse = embeddingModel
-        .embedForResponse(List.of("Hello World", "World is big and salvation is near"));
-```
diff --git a/src/content/docs/ai/zh-cn/tutorials/function-calling.md b/src/content/docs/ai/zh-cn/tutorials/function-calling.md
deleted file mode 100644
index 6538b99ff..000000000
--- a/src/content/docs/ai/zh-cn/tutorials/function-calling.md
+++ /dev/null
@@ -1,255 +0,0 @@
----
-title: 工具(Function Calling)
-keywords: [Spring AI,通义千问,百炼,智能体应用]
-description: "Spring AI 与通义千问集成，使用 Spring AI 开发 Java AI 应用。"
----
-
-“工具（Tool）”或“功能调用（Function Calling）”允许大型语言模型（LLM）在必要时调用一个或多个可用的工具，这些工具通常由开发者定义。工具可以是任何东西：网页搜索、对外部 API 的调用，或特定代码的执行等。LLM 本身不能实际调用工具；相反，它们会在响应中表达调用特定工具的意图（而不是以纯文本回应）。然后，我们应用程序应该执行这个工具，并报告工具执行的结果给模型。
-
-例如，我们知道 LLM 自身在数学方面不是特别擅长。如果你的用例偶尔涉及数学计算，你可能会想提供给 LLM 一个“数学工具”。通过在请求中声明一个或多个工具，LLM 可以在认为合适时调用其中之一。给定一个数学问题和一组数学工具，LLM 可能会决定为正确回答问题，它应该首先调用其中一个提供的数学工具。
-
-接下来，让我们用一个示例看一下 Function Calling 的具体工作过程。
-
-以下是没有 Function Calling 的一个消息交互过程示例，模型给给出的结果非常接近但是并不正确：
-
-```text
-Request:
-- messages:
-    - UserMessage:
-        - text: What is the square root of 475695037565?
-
-Response:
-- AiMessage:
-    - text: The square root of 475695037565 is approximately 689710.
-```
-
-以下是包含了 Function Calling 的消息交互过程：
-
-```text
-Request 1:
-- messages:
-    - UserMessage:
-        - text: What is the square root of 475695037565?
-- tools:
-    - sum(double a, double b): Sums 2 given numbers
-    - squareRoot(double x): Returns a square root of a given number
-
-Response 1:
-- AiMessage:
-    - toolExecutionRequests:
-        - squareRoot(475695037565)
-
-
-... here we are executing the squareRoot method with the "475695037565" argument and getting "689706.486532" as a result ...
-
-
-Request 2:
-- messages:
-    - UserMessage:
-        - text: What is the square root of 475695037565?
-    - AiMessage:
-        - toolExecutionRequests:
-            - squareRoot(475695037565)
-    - ToolExecutionResultMessage:
-        - text: 689706.486532
-
-Response 2:
-- AiMessage:
-    - text: The square root of 475695037565 is 689706.486532.
-```
-
-其中，函数定义如下：
-```java
-@Bean
-@Description("Get the weather in location") // function description
-public Function<MockWeatherService.Request, MockWeatherService.Response> weatherFunction1() {
-	return new MockWeatherService();
-}
-```
-
-正如你所看到的，当 LLM 可以访问工具时，它可以在合适的情况下决定调用其中一个工具，这是一个非常强大的功能。在这个简单的示例中，我们给 LLM 提供了基本的数学工具，但想象一下，如果我们给它提供了，比如说，googleSearch 和 sendEmail 工具，并且有一个查询像是“我的朋友想了解 AI 领域的最新新闻。将简短的总结发送到 friend@email.com”，那么它可以使用 googleSearch 工具查找最新新闻，然后总结这些信息并通过 sendEmail 工具将总结发送到指定的邮箱。
-
-## API 概览
-
-通常，自定义函数需要提供一个 `name`、`description` 和 `function call signature`，以便模型知道函数能做什么、期望的输入参数。
-
-Spring AI 使这一过程变得简单，只需定义一个返回 `java.util.Function` 的 @Bean 定义，并在调用 ChatModel 时将 bean 名称作为选项进行注册。在底层，Spring 会用适当的适配器代码包装你的 POJO（即函数），以便与 AI 模型进行交互，免去了编写繁琐的样板代码。`FunctionCallback.java`  接口和配套的 `FunctionCallbackWrapper.java` 工具类包含了底层实现代码，它们是简化 Java 回调函数的实现和注册的关键。
-
-![function calling flow](https://img.alicdn.com/imgextra/i1/O1CN01CfzrO11PzHs9GTPKG_!!6000000001911-0-tps-2372-1685.jpg)
-
-## 使用示例
-在以下示例中，我们将创建一个聊天机器人，通过调用我们自己的函数来回答问题。为了支持聊天机器人的响应，我们将注册一个自己的函数，该函数接受一个位置并返回该位置的当前天气。当模型需要回答诸如 “What’s the weather like in Boston?” 这样的问题时，AI 模型将调用客户端，将位置值作为参数传递给函数。这种类似 RPC 的数据将以 JSON 格式传递。
-
-我们的函数调用某个基于 SaaS 的天气服务 API，并将天气响应返回给模型以完成对话。在这个示例中，我们将使用一个名为 MockWeatherService 的简单实现，它为不同位置硬编码了温度。
-
-> 示例源码请参见 [function-calling-example](https://github.com/alibaba/spring-ai-alibaba/tree/main/spring-ai-alibaba-examples/function-calling-example)
-
-以下是代表天气服务 API 的 MockWeatherService.java：
-
-```java
-public class MockWeatherService implements Function<Request, Response> {
-	public enum Unit { C, F }
-	public record Request(String location, Unit unit) {}
-	public record Response(double temp, Unit unit) {}
-
-	public Response apply(Request request) {
-		return new Response(30.0, Unit.C);
-	}
-}
-```
-
-### 定义&注册函数
-
-通过这种方法，您可以在应用程序上下文中定义 @Beans，就像定义任何其他 Spring 管理对象一样。
-
-在内部，Spring AI ChatModel 将创建一个 FunctionCallbackWrapper 包装器的实例，该包装器添加通过 AI 模型调用它的逻辑。@Bean 的名称作为 ChatOption 传递。
-
-```java
-@Configuration
-static class Config {
-	@Bean
-	@Description("Get the weather in location") // function description
-	public Function<MockWeatherService.Request, MockWeatherService.Response> weatherFunction1() {
-		return new MockWeatherService();
-	}
-	...
-}
-```
-
-@Description 注释是可选的，它提供了函数描述 (2)，可帮助模型了解何时调用该函数。这是一个重要的属性，可帮助 AI 模型确定要调用哪个客户端函数。
-
-提供函数描述的另一种选择是使用 MockWeatherService.Request 上的 @JsonClassDescription 注释来提供函数描述：
-
-```java
-@Configuration
-static class Config {
-	@Bean
-	public Function<Request, Response> currentWeather3() { // (1) bean name as function name.
-		return new MockWeatherService();
-	}
-	...
-}
-
-@JsonClassDescription("Get the weather in location") // (2) function description
-public record Request(String location, Unit unit) {}
-```
-
-最佳做法是使用信息注释请求对象，以便该函数生成的 JSON 模式尽可能具有描述性，以帮助 AI 模型选择要调用的正确函数。
-
-如果已经有定义的@Service，那么可以通过以下方式来通过function call来调用已有的service的方法。
-```java
-// 1. 已存在的MockOrderService
-@Service
-public class MockOrderService {
-    public Response getOrder(Request request) {
-        String productName = "尤尼克斯羽毛球拍";
-        return new Response(String.format("%s的订单编号为%s, 购买的商品为: %s", request.userId, request.orderId, productName));
-    }
-
-    @JsonInclude(JsonInclude.Include.NON_NULL)
-    public record Request(
-            //这里的JsonProperty将转换为function的parameters信息, 包括参数名称和参数描述等
-            /*
-             {
-                "orderId": {
-                    "type": "string",
-                    "description": "订单编号, 比如1001***"
-                    },
-                "userId": {
-                    "type": "string",
-                    "description": "用户编号, 比如2001***"
-                }
-            }
-            */
-            @JsonProperty(required = true, value = "orderId") @JsonPropertyDescription("订单编号, 比如1001***") String orderId,
-            @JsonProperty(required = true, value = "userId") @JsonPropertyDescription("用户编号, 比如2001***") String userId) {
-    }
-
-    public record Response(String description) {
-    }
-}
-
-//2. 将MockOrderService的getOrder注册为function call的bean
-@Configuration
-public class FunctionCallConfiguration {
-    @Bean
-    @Description("根据用户编号和订单编号查询订单信息")  //function的描述
-    public Function<MockOrderService.Request, MockOrderService.Response> getOrderFunction(MockOrderService mockOrderService) {
-        return mockOrderService::getOrder;
-    }
-}
-
-//3. 调用function call
-DashScopeChatModel dashscopeChatModel = ...;
-ChatClient chatClient = ChatClient.builder(dashscopeChatModel)
-        .defaultFunctions("getOrderFunction")
-        .build();
-
-ChatResponse response = chatClient
-        .prompt()
-        .user("帮我一下订单, 用户编号为1001, 订单编号为2001")
-        .call()
-        .chatResponse();
-
-String content = response.getResult().getOutput().getContent();
-logger.info("content: {}", content);
-
-```
-
-> 还有一种函数注册方式是使用 `FunctionCallbackWrapper`，具体请查看示例仓库中的源码。
-
-### 为 Prompt 指定函数
-为了让模型知道并调用您的 CurrentWeather 函数，您需要在 Prompt 请求中启用它。
-
-#### ChatClient
-
-```java
-	ChatResponse response = chatClient.prompt()
-		.functions("CurrentWeather")
-		.user("What's the weather like in San Francisco, Tokyo, and Paris?")
-		.call()
-		.chatResponse();
-```
-
-#### ChatModel
-
-```java
-OpenAiChatModel chatModel = ...
-
-UserMessage userMessage = new UserMessage("What's the weather like in San Francisco, Tokyo, and Paris?");
-
-ChatResponse response = chatModel.call(new Prompt(List.of(userMessage),
-		OpenAiChatOptions.builder().withFunction("CurrentWeather").build())); // (1) Enable the function
-
-logger.info("Response: {}", response);
-```
-
-上述用户问题将触发 3 次对 CurrentWeather 函数的调用（每个城市一次），最终的响应将是这样的：
-
-```text
-Here is the current weather for the requested cities:
-- San Francisco, CA: 30.0°C
-- Tokyo, Japan: 10.0°C
-- Paris, France: 15.0°C
-```
-
-### 动态注册函数
-
-除了自动配置之外，您还可以使用 Prompt 请求动态注册回调函数：
-
-```java
-OpenAiChatModel chatModel = ...
-
-UserMessage userMessage = new UserMessage("What's the weather like in San Francisco, Tokyo, and Paris?");
-
-var promptOptions = OpenAiChatOptions.builder()
-	.withFunctionCallbacks(List.of(new FunctionCallbackWrapper<>(
-		"CurrentWeather", // name
-		"Get the weather in location", // function description
-		new MockWeatherService()))) // function code
-	.build();
-
-ChatResponse response = chatModel.call(new Prompt(List.of(userMessage), promptOptions));
-```
-
-这种方法允许根据用户输入动态选择要调用的不同函数，无需预先声明函数为 bean 实例。
diff --git a/src/content/docs/ai/zh-cn/tutorials/memory.md b/src/content/docs/ai/zh-cn/tutorials/memory.md
deleted file mode 100644
index aae7d07c4..000000000
--- a/src/content/docs/ai/zh-cn/tutorials/memory.md
+++ /dev/null
@@ -1,85 +0,0 @@
----
-title: 对话记忆
-keywords: [Spring AI,通义千问,百炼,智能体应用]
-description: "Spring AI 与通义千问集成，使用 Spring AI 开发 Java AI 应用。"
----
-
-## 对话记忆介绍
-
-"大模型的对话记忆"这一概念，根植于人工智能与自然语言处理领域，特别是针对具有深度学习能力的大型语言模型而言，它指的是模型在与用户进行交互式对话过程中，能够追踪、理解并利用先前对话上下文的能力。
-此机制使得大模型不仅能够响应即时的输入请求，还能基于之前的交流内容能够在对话中记住先前的对话内容，并根据这些信息进行后续的响应。这种记忆机制使得模型能够在对话中持续跟踪和理解用户的意图和上下文，从而实现更自然和连贯的对话。
-
-我们在调用大模型的过程中，如果自己维护多轮的对话记忆，通常情况下调用代码如下
-
-```java
-import java.util.ArrayList;
-
-List<Message> messages = new ArrayList<>();
-
-//第一轮对话
-messages.add(new SystemMessage("你是一个旅游规划师"));
-messages.add(new UserMessage("我想去新疆"));
-ChatResponse response = chatModel.call(new Prompt(messages));
-String content = response.getResult().getOutput().getContent();
-        
-messages.add(new AssistantMessage(content));
-
-        //第二轮对话
-messages.add(new UserMessage("能帮我推荐一些旅游景点吗?"));
-response = chatModel.call(new Prompt(messages));
-content = response.getResult().getOutput().getContent();
-
-messages.add(new AssistantMessage(content));
-
-        //第三轮对话
-messages.add(new UserMessage("那里这两天的天气如何?"));
-response = chatModel.call(new Prompt(messages));
-content = response.getResult().getOutput().getContent();
-
-System.out.printf("content: %s\n", content);
-
-```
-
-## 基于memory的对话记忆
-
-spring-ai-alibaba支持基于chat memory的对话记忆，也就是不需要调用显示的记录每一轮的对话历史。下边是一个基于内存存储的对话记忆实现:
-
-```java
-        //初始化基于内存的对话记忆
-        ChatMemory chatMemory = new InMemoryChatMemory();
-
-        DashScopeChatModel chatModel = ...;
-        ChatClient chatClient = ChatClient.builder(dashscopeChatModel)
-        .defaultAdvisors(new MessageChatMemoryAdvisor(chatMemory))
-        .build();
-
-        //对话记忆的唯一标识
-        String conversantId = UUID.randomUUID().toString();
-
-        ChatResponse response = chatClient
-                .prompt()
-                .user("我想去新疆")
-                .advisors(spec -> spec.param(CHAT_MEMORY_CONVERSATION_ID_KEY, conversantId)
-                        .param(CHAT_MEMORY_RETRIEVE_SIZE_KEY, 10))
-                .call()
-                .chatResponse();
-        String content = response.getResult().getOutput().getContent();
-        Assertions.assertNotNull(content);
-
-        logger.info("content: {}", content);
-
-        response = chatClient
-                .prompt()
-                .user("可以帮我推荐一些美食吗")
-                .advisors(spec -> spec.param(CHAT_MEMORY_CONVERSATION_ID_KEY, conversantId)
-                        .param(CHAT_MEMORY_RETRIEVE_SIZE_KEY, 10))
-                .call()
-                .chatResponse();
-        content = response.getResult().getOutput().getContent();
-        Assertions.assertNotNull(content);
-
-        logger.info("content: {}", content);
-
-```
-
-当然，开发者也可以自行实现ChatMemory基于类似于文件、Redis等方式进行上下文内容的存储和记录。
\ No newline at end of file
diff --git a/src/content/docs/ai/zh-cn/tutorials/prompt.md b/src/content/docs/ai/zh-cn/tutorials/prompt.md
deleted file mode 100644
index 7104b5350..000000000
--- a/src/content/docs/ai/zh-cn/tutorials/prompt.md
+++ /dev/null
@@ -1,183 +0,0 @@
----
-title: 提示词 (Prompt)
-keywords: [Spring AI,通义千问,百炼,智能体应用]
-description: "Spring AI 与通义千问集成，使用 Spring AI 开发 Java AI 应用。"
----
-
-Prompt 是引导 AI 模型生成特定输出的输入格式，Prompt 的设计和措辞会显著影响模型的响应。
-
-Prompt 最开始只是简单的字符串，随着时间的推移，prompt 逐渐开始包含特定的占位符，例如 AI 模型可以识别的 “USER:”、“SYSTEM:” 等。阿里云通义模型可通过将多个消息字符串分类为不同的角色，然后再由 AI 模型处理，为 prompt 引入了更多结构。每条消息都分配有特定的角色，这些角色对消息进行分类，明确 AI 模型提示的每个部分的上下文和目的。这种结构化方法增强了与 AI 沟通的细微差别和有效性，因为 prompt 的每个部分在交互中都扮演着独特且明确的角色。
-
-Prompt 中的主要角色（Role）包括：
-
-* 系统角色（System Role）：指导 AI 的行为和响应方式，设置 AI 如何解释和回复输入的参数或规则。这类似于在发起对话之前向 AI 提供说明。
-* 用户角色（User Role）：代表用户的输入 - 他们向 AI 提出的问题、命令或陈述。这个角色至关重要，因为它构成了 AI 响应的基础。
-* 助手角色（Assistant Role）：AI 对用户输入的响应。这不仅仅是一个答案或反应，它对于保持对话的流畅性至关重要。通过跟踪 AI 之前的响应（其“助手角色”消息），系统可确保连贯且上下文相关的交互。助手消息也可能包含功能工具调用请求信息。它就像 AI 中的一个特殊功能，在需要执行特定功能（例如计算、获取数据或不仅仅是说话）时使用。
-* 工具/功能角色（Tool/Function Role）：工具/功能角色专注于响应工具调用助手消息返回附加信息。
-
-
-## API 概览
-### Prompt
-通常使用 ChatModel 的 call() 方法，该方法接受 Prompt 实例并返回 ChatResponse。
-
-Prompt 类充当有组织的一系列 Message 对象和请求 ChatOptions 的容器。每条消息在提示中都体现了独特的角色，其内容和意图各不相同。这些角色可以包含各种元素，从用户查询到 AI 生成的响应再到相关背景信息。这种安排可以实现与 AI 模型的复杂而详细的交互，因为提示是由多条消息构成的，每条消息都被分配了在对话中扮演的特定角色。
-
-下面是 Prompt 类的截断版本，为简洁起见省略了构造函数和实用方法：
-
-```java
-public class Prompt implements ModelRequest<List<Message>> {
-
-    private final List<Message> messages;
-
-    private ChatOptions chatOptions;
-}
-```
-
-#### Message
-Message 接口封装了一个提示文本、一组元数据属性以及一个称为 MessageType 的分类。
-
-该接口定义如下：
-
-```java
-public interface Content {
-
-	String getContent();
-
-	Map<String, Object> getMetadata();
-}
-
-public interface Message extends Content {
-
-	MessageType getMessageType();
-}
-```
-
-Message 接口的各种实现对应 AI 模型可以处理的不同类别的消息。模型根据对话角色区分消息类别。
-
-![message class diagram](https://img.alicdn.com/imgextra/i4/O1CN01LoRnWM1iHkvWVQTbd_!!6000000004388-0-tps-4379-3653.jpg)
-
-
-#### Role
-
-角色在 Spring AI 中表示为枚举，如下所示：
-
-```java
-public enum MessageType {
-	USER("user"),
-	ASSISTANT("assistant"),
-	SYSTEM("system"),
-	TOOL("tool");
-}
-```
-
-### Prompt Template
-
-Spring AI 中用于提示模板的关键组件是 PromptTemplate 类。该类使用 Terence Parr 开发的 OSS StringTemplate 引擎来构建和管理提示。PromptTemplate 类旨在促进结构化提示的创建，然后将其发送到 AI 模型进行处理
-
-```java
-public class PromptTemplate implements PromptTemplateActions, PromptTemplateMessageActions {
-    // Other methods to be discussed later
-}
-```
-
-该类实现的接口支持提示创建的不同方面：
-
-PromptTemplateStringActions 专注于创建和呈现提示字符串，代表提示生成的最基本形式。
-
-PromptTemplateMessageActions 专门用于通过生成和操作 Message 对象来创建提示。
-
-PromptTemplateActions 旨在返回 Prompt 对象，该对象可以传递给 ChatModel 以生成响应。
-
-虽然这些接口可能在许多项目中没有得到广泛使用，但它们展示了创建提示的不同方法。
-
-实现的接口是
-
-```java
-public interface PromptTemplateStringActions {
-
-	String render();
-
-	String render(Map<String, Object> model);
-
-}
-```
-
-方法 String render()：将提示模板渲染为最终字符串格式，无需外部输入，适用于没有占位符或动态内容的模板。
-
-方法 String render(Map<String, Object> model)：增强渲染功能以包含动态内容。它使用 Map<String, Object>，其中映射键是提示模板中的占位符名称，值是要插入的动态内容。
-
-```java
-public interface PromptTemplateMessageActions {
-
-	Message createMessage();
-
-    Message createMessage(List<Media> mediaList);
-
-	Message createMessage(Map<String, Object> model);
-
-}
-```
-
-方法 Message createMessage()：创建一个不带附加数据的 Message 对象，用于静态或预定义消息内容。
-
-方法 Message createMessage(List<Media> mediaList)：创建一个带有静态文本和媒体内容的 Message 对象。
-
-方法 Message createMessage(Map<String, Object> model)：扩展消息创建以集成动态内容，接受 Map<String, Object>，其中每个条目代表消息模板中的占位符及其对应的动态值。
-
-```java
-public interface PromptTemplateActions extends PromptTemplateStringActions {
-
-	Prompt create();
-
-	Prompt create(ChatOptions modelOptions);
-
-	Prompt create(Map<String, Object> model);
-
-	Prompt create(Map<String, Object> model, ChatOptions modelOptions);
-
-}
-```
-
-方法 Prompt create()：生成不带外部数据输入的 Prompt 对象，非常适合静态或预定义提示。
-
-方法 Prompt create(ChatOptions modelOptions)：生成一个 Prompt 对象，无需外部数据输入，但具有聊天请求的特定选项。
-
-方法 Prompt create(Map<String, Object> model)：扩展提示创建功能以包含动态内容，采用 Map<String, Object>，其中每个映射条目都是提示模板中的占位符及其关联的动态值。
-
-方法 Prompt create(Map<String, Object> model, ChatOptions modelOptions)：扩展提示创建功能以包含动态内容，采用 Map<String, Object>，其中每个映射条目都是提示模板中的占位符及其关联的动态值，以及聊天请求的特定选项。
-
-## 使用示例
-
-完整示例源码请参见 [prompt-example](https://github.com/alibaba/spring-ai-alibaba/tree/main/spring-ai-alibaba-examples/prompt-example)。
-
-```java
-PromptTemplate promptTemplate = new PromptTemplate("Tell me a {adjective} joke about {topic}");
-
-Prompt prompt = promptTemplate.create(Map.of("adjective", adjective, "topic", topic));
-
-return chatModel.call(prompt).getResult();
-```
-
-
-
-```java
-String userText = """
-    Tell me about three famous pirates from the Golden Age of Piracy and why they did.
-    Write at least a sentence for each pirate.
-    """;
-
-Message userMessage = new UserMessage(userText);
-
-String systemText = """
-  You are a helpful AI assistant that helps people find information.
-  Your name is {name}
-  You should reply to the user's request with your name and also in the style of a {voice}.
-  """;
-
-SystemPromptTemplate systemPromptTemplate = new SystemPromptTemplate(systemText);
-Message systemMessage = systemPromptTemplate.createMessage(Map.of("name", name, "voice", voice));
-
-Prompt prompt = new Prompt(List.of(userMessage, systemMessage));
-
-List<Generation> response = chatModel.call(prompt).getResults();
-```
\ No newline at end of file
diff --git a/src/content/docs/ai/zh-cn/tutorials/retriever.md b/src/content/docs/ai/zh-cn/tutorials/retriever.md
deleted file mode 100644
index 7aece2394..000000000
--- a/src/content/docs/ai/zh-cn/tutorials/retriever.md
+++ /dev/null
@@ -1,153 +0,0 @@
----
-title: 文档检索 (Document Retriever)
-keywords: [Spring AI,通义千问,百炼,智能体应用]
-description: "Spring AI 与通义千问集成，使用 Spring AI 开发 Java AI 应用。"
----
-
-## 核心概念
-文档检索（`DocumentRetriever`）是一种信息检索技术，旨在从大量未结构化或半结构化文档中快速找到与特定查询相关的文档或信息。文档检索通常以在线(online)方式运行。
-
-`DocumentRetriever`通常基于向量搜索。它将用户的查询问题(query)转化为Embeddings后，在存储文档中进行相似性搜索，返回相关的片段。片段的用途之一是作为提示词(prompt)的一部分，发送给大模型(LLM)汇总处理后，作为答案呈现给用户。
-
-`DocumentRetriever API`提供了简单、灵活的方式，供开发者使用自定义的检索系统。
-
-## API介绍
-本节介绍DocumentRetriever的接口和类。
-### DocumentRetriever
-```java
-public interface DocumentRetriever extends Function<String, List<Document>> {
-    List<Document> retrieve(String query);
-
-    default List<Document> apply(String query) {
-        return this.retrieve(query);
-    }
-}
-```
-DocumentRetriever API简单地将用户的查询作为输入，返回文档片段(`Document`)的列表。
-
-通过`retrieve`方法，用户可以执行自定义的检索步骤。
-
-#### Document
-`Document`表示一个文档片段，它包含一个文本内容，以及一个或多个元数据。
-```java
-@JsonIgnoreProperties({"contentFormatter"})
-public class Document implements MediaContent {
-    public static final ContentFormatter DEFAULT_CONTENT_FORMATTER = DefaultContentFormatter.defaultConfig();
-    public static final String EMPTY_TEXT = "";
-    private final String id;
-    private Map<String, Object> metadata;
-    private final String content;
-    private final Collection<Media> media;
-    @JsonProperty(
-            index = 100
-    )
-    private float[] embedding;
-    @JsonIgnore
-    private ContentFormatter contentFormatter;
-
-    @JsonCreator(
-            mode = Mode.PROPERTIES
-    )
-    // other methods omitted
-}
-```
-## 示例用法
-Spring AI Alibaba已经集成了`阿里云百炼平台`，接下来介绍基于阿里云百炼平台调用 DocumentRetriever API。
-
-### 准备工作
-由于百炼平台仅支持云端检索，因此在开始之前，参考如下链接获取API-KEY：[获取API-KEY](https://help.aliyun.com/zh/model-studio/developer-reference/get-api-key)。
-然后，在项目环境中设置API-KEY，有两种方式：
-
-- 方式一：设置`configuration properties：spring.ai.dashscope.api-key` 为上述API-KEY。
-- 方式二：设置环境变量`export SPRING_AI_DASHSCOPE_API_KEY=<YOUR API  KEY>`
-
-### Auto-configuration
-Spring AI 为 DashScopeDocumentRetriever 提供了 Spring Boot 的自动配置。要启用此功能，请将以下依赖项添加到您项目的 Maven`pom.xml`文件中：
-```xml
-<dependency>
-    <groupId>org.springframework.ai</groupId>
-    <artifactId>spring-ai-dashscope-spring-boot-starter</artifactId>
-</dependency>
-```
-或者添加到您的Gradle`build.gradle`文件中：
-```gradle
-dependencies {
-    implementation 'org.springframework.ai:spring-ai-dashscope-spring-boot-starter'
-}
-```
-#### Retriever Properties
-前缀`spring.ai.dashscope`是用于配置连接至 DashScope 的属性前缀。
-
-| Property                       | Action          | Default |
-|:-------------------------------|:----------------|---------|
-| `spring.ai.dashscope.api-key`  | 来自百炼平台的API KEY  | -       |
-
-
-```tips
-所有以 spring.ai.dashscope 开头的属性都可以在构造DashScopeDocumentRetriever时传入Runtime Options来覆盖。
-```
-
-### Runtime Options
-`DashScopeDocumentRetrieverOptions`提供了DashScopeDocumentRetriever的配置信息，它通过构建器创建选项。
-
-在构造`DashScopeDocumentRetriever`时，通过将一个`DashScopeDocumentRetrieverOptions`实例传入，已完成配置。
-
-例如，使用指定的知识库：
-```java
-DocumentRetriever retriever = new DashScopeDocumentRetriever(dashscopeApi,
-        DashScopeDocumentRetrieverOptions.builder()
-                .withIndexName("spring-ai知识库")
-                .build());
-```
-### 示例代码
-该示例将创建一个`DashScopeDocumentRetriever`实例，在指定的知识库上执行检索操作。以下是简单的`@Controller`类的示例，它使用了该 DashScopeDocumentRetriever 实例。
-```properties
-spring.ai.dashscope.api-key=YOUR_API_KEY
-```
-```java
-@RestController
-public class RetrieverController {
-
-    private final DocumentRetriever documentRetriever;
-
-    @Autowired
-    public RetrieverController(DocumentRetriever documentRetriever) {
-        this.documentRetriever = documentRetriever;
-    }
-
-    @GetMapping("/ai/retrieve")
-    public List<Document> retrieve(@RequestParam(value = "message", defaultValue = "What's spring ai") String message) {
-        return this.documentRetriever.retrieve(message);
-    }
-}
-```
-
-### Manual Configuration
-如果您不希望使用 Spring Boot 的 Auto-configuration，可以在应用程序中手动配置`DashScopeDocumentRetriever`。为此，请将`spring.ai.dashscope`依赖项添加到您项目的 Maven`pom.xml`文件中：
-```xml
-<dependency>
-    <groupId>org.springframework.ai</groupId>
-    <artifactId>spring-ai-dashscope</artifactId>
-</dependency>
-```
-
-或者添加到您的Gradle`build.gradle`文件中：
-```gradle
-dependencies {
-    implementation 'org.springframework.ai:spring-ai-dashscope'
-}
-```
-```note
-spring-ai-dashcope 依赖项还提供了对 DashScopeChatModel 的访问。有关 DashScopeChatModel 的更多信息，请参考 DashScope Chat Client部分。
-```
-
-接下来，创建一个`DocumentRetriever`实例，并使用它检索文档片段：
-```java
-var dashScopeApi = new DashScopeApi(System.getenv("DASHSCOPE_API_KEY"));
-DocumentRetriever retriever = new DashScopeDocumentRetriever(dashScopeApi,
-        DashScopeDocumentRetrieverOptions.builder()
-                .withIndexName("spring-ai知识库")
-                .build());
-
-List<Document> documentList = retriever.retrieve("What's spring ai");
-```
\ No newline at end of file
diff --git a/src/content/docs/ai/zh-cn/tutorials/structured-output.md b/src/content/docs/ai/zh-cn/tutorials/structured-output.md
deleted file mode 100644
index fbcce5520..000000000
--- a/src/content/docs/ai/zh-cn/tutorials/structured-output.md
+++ /dev/null
@@ -1,104 +0,0 @@
----
-title: 格式化输出(Structured Output)
-keywords: [Chat Model, 聊天, 对话]
-description: "Spring AI 与通义千问集成，使用 Spring AI 开发 Java AI 应用。"
----
-
-如果您想从 LLM 接收结构化输出，Structured Output 可以协助将 `ChatModel/ChatClient` 方法的返回类型从 String 更改为其他类型。
-
-LLM 生成结构化输出的能力对于依赖可靠解析输出值的下游应用程序非常重要。开发人员希望快速将 AI 模型的结果转换为可以传递给其他应用程序函数和方法的数据类型，例如 JSON、XML 或 Java 类。Spring AI 结构化输出转换器有助于将 LLM 输出转换为结构化格式。
-
-![structured output flow](https://img.alicdn.com/imgextra/i2/O1CN01JozLPb1zIX4DMaXTO_!!6000000006691-0-tps-2809-1423.jpg)
-
-在 LLM 调用之前，转换器会将期望的输出格式（output format instruction）附加到 prompt 中，为模型提供生成所需输出结构的明确指导，这些指令充当蓝图，塑造模型的响应以符合指定的格式。以下是此类格式说明的示例：
-
-```text
-Your response should be in JSON format.
-The data structure for the JSON should match this Java class: java.util.HashMap
-Do not include any explanations, only provide a RFC8259 compliant JSON response following this format without deviation.
-```
-
-在 LLM 调用之后，转换器获取模型的输出文本并将其转换为结构化类型的实例，此转换过程涉及解析原始文本输出并将其映射到相应的结构化数据表示，例如 JSON、XML 或特定于域的数据结构。
-
-## API 概述
-
-当前 Spring AI 提供的 Converter 实现有 `AbstractConversionServiceOutputConverter`, `AbstractMessageOutputConverter`, `BeanOutputConverter`, `MapOutputConverter` and `ListOutputConverter`。
-
-![structured output class hierarchy](https://img.alicdn.com/imgextra/i2/O1CN01JTh3dN1iXmmroxnYo_!!6000000004423-0-tps-2864-1396.jpg)
-
-* BeanOutputConverter<T> - 使用指定的 Java 类（例如 Bean）或 ParameterizedTypeReference 配置，此转换器指示 AI 模型生成符合 DRAFT_2020_12 的 JSON 响应，JSON 模式派生自指定的 Java 类，随后，它利用 ObjectMapper 将 JSON 输出反序列化为目标类的 Java 对象实例。
-* MapOutputConverter - 该实现指导 AI 模型生成符合 RFC8259 的 JSON 响应，此外，它还包含一个转换器实现，该实现利用提供的 MessageConverter 将 JSON 负载转换为 java.util.Map<String, Object> 实例。
-* ListOutputConverter - 该实现指导 AI 模型生成逗号分隔的格式化输出，最终转换器将模型文本输出转换为 java.util.List。
-
-## 使用示例
-
-格式化输出工具的使用非常简单，以下是 `ChatClient` 和 `ChatModel` 两种使用示例。完整是示例源码请参见 [structured-output-example](https://github.com/alibaba/spring-ai-alibaba/tree/main/spring-ai-alibaba-examples/structured-output-example)
-
-假设我们期望将模型输出转换为以下结构体：
-```java
-record ActorsFilms(String actor, List<String> movies) {
-}
-```
-
-### ChatClient
-将模型响应转换为 ActorsFilms 对象实例：
-
-```java
-ActorsFilms actorsFilms = ChatClient.create(chatModel).prompt()
-        .user(u -> u.text("Generate the filmography of 5 movies for {actor}.")
-                    .param("actor", "Tom Hanks"))
-        .call()
-        .entity(ActorsFilms.class);
-```
-
-或者，将模型响应转换为 List<ActorsFilms> 对象实例：
-
-```java
-List<ActorsFilms> actorsFilms = ChatClient.create(chatModel).prompt()
-        .user("Generate the filmography of 5 movies for Tom Hanks and Bill Murray.")
-        .call()
-        .entity(new ParameterizedTypeReference<List<ActorsFilms>>() {});
-```
-
-将模型响应转换为 Map<String, Object>：
-
-```java
-Map<String, Object> result = ChatClient.create(chatModel).prompt()
-        .user(u -> u.text("Provide me a List of {subject}")
-                    .param("subject", "an array of numbers from 1 to 9 under their key name 'numbers'"))
-        .call()
-        .entity(new ParameterizedTypeReference<Map<String, Object>>() {});
-```
-
-使用 `ListOutputConverter` 将模型响应转换为 List<String>：
-
-```java
-List<String> flavors = ChatClient.create(chatModel).prompt()
-                .user(u -> u.text("List five {subject}")
-                            .param("subject", "ice cream flavors"))
-                .call()
-                .entity(new ListOutputConverter(new DefaultConversionService()));
-```
-
-### ChatModel
-
-如果您使用的更底层的原子 API，则使用如下方式进行格式化输出转换：
-
-```java
-BeanOutputConverter<ActorsFilms> beanOutputConverter =
-    new BeanOutputConverter<>(ActorsFilms.class);
-
-String format = beanOutputConverter.getFormat();
-
-String actor = "Tom Hanks";
-
-String template = """
-        Generate the filmography of 5 movies for {actor}.
-        {format}
-        """;
-
-Generation generation = chatModel.call(
-    new PromptTemplate(template, Map.of("actor", actor, "format", format)).create()).getResult();
-
-ActorsFilms actorsFilms = beanOutputConverter.convert(generation.getOutput().getContent());
-```
diff --git a/src/content/docs/ai/zh-cn/tutorials/vectorstore.md b/src/content/docs/ai/zh-cn/tutorials/vectorstore.md
deleted file mode 100644
index d6a5b3c6f..000000000
--- a/src/content/docs/ai/zh-cn/tutorials/vectorstore.md
+++ /dev/null
@@ -1,170 +0,0 @@
----
-title: 向量存储(Vector Store)
-keywords: [Spring AI,通义千问,百炼,智能体应用]
-description: "Spring AI 与通义千问集成，使用 Spring AI 开发 Java AI 应用。"
----
-
-## 核心概念
-向量存储（`VectorStore`）是一种用于存储和检索高维向量数据的数据库或存储解决方案，它特别适用于处理那些经过嵌入模型转化后的数据。在 VectorStore 中，查询与传统关系数据库不同。它们执行相似性搜索，而不是精确匹配。当给定一个向量作为查询时，VectorStore 返回与查询向量“相似”的向量。
-
-VectorStore 用于将您的数据与 AI 模型集成。在使用它们时的第一步是将您的数据加载到矢量数据库中。然后，当要将用户查询发送到 AI 模型时，首先检索一组相似文档。然后，这些文档作为用户问题的上下文，并与用户的查询一起发送到 AI 模型。这种技术被称为检索增强生成（`Retrieval Augmented Generation，RAG`）。
-
-VectorStore API提供了简单易用的接口供开发者对 VectorStore 进行操作，接下来的部分描述相关接口以及一些高层次的示例用法。
-
-## API介绍
-本节是对 Spring AI 框架中`VectorStore`接口及其相关类的指南。
-
-Spring AI 提供了一个抽象化的 API，通过 VectorStore 接口与向量数据库进行交互。
-### VectorStore
-以下是`VectorStore`接口的定义：
-```java
-public interface VectorStore extends DocumentWriter {
-    default String getName() {
-        return this.getClass().getSimpleName();
-    }
-
-    void add(List<Document> documents);
-
-    default void accept(List<Document> documents) {
-        this.add(documents);
-    }
-
-    Optional<Boolean> delete(List<String> idList);
-
-    List<Document> similaritySearch(SearchRequest request);
-
-    default List<Document> similaritySearch(String query) {
-        return this.similaritySearch(SearchRequest.query(query));
-    }
-}
-```
-以及相关的`SearchRequest`构建器：
-```java
-public class SearchRequest {
-
-    public final String query;
-    private int topK = 4;
-    private double similarityThreshold = SIMILARITY_THRESHOLD_ALL;
-    private Filter.Expression filterExpression;
-
-    public static SearchRequest query(String query) { return new SearchRequest(query); }
-
-    private SearchRequest(String query) { this.query = query; }
-
-    public SearchRequest withTopK(int topK) {...}
-    public SearchRequest withSimilarityThreshold(double threshold) {...}
-    public SearchRequest withSimilarityThresholdAll() {...}
-    public SearchRequest withFilterExpression(Filter.Expression expression) {...}
-    public SearchRequest withFilterExpression(String textExpression) {...}
-
-    public String getQuery() {...}
-    public int getTopK() {...}
-    public double getSimilarityThreshold() {...}
-    public Filter.Expression getFilterExpression() {...}
-}
-```
-
-要将数据插入 VectorStore，应先将其封装在`Document`对象中。`Document`类封装了来自数据源（如 PDF 或 Word 文档）的内容，并将文本表示为字符串。它还包含键值对形式的元数据，包括文件名等详细信息。
-
-在将文本内容插入 VectorStore 时，使用 EmbeddingModel 将文本内容转换为数值数组或float[]，这一步称为向量 Embedding。EmbeddingModel 用于将单词、句子或段落转换为这些向量 Embeddings。
-
-VectorStore 的作用是存储并支持对这些 Embeddings 的相似性搜索，它不会生成 Embeddings 本身。因此，VectorStore 需要和 EmbeddingModel 一起使用。
-
-接口中的`similaritySearch`方法允许检索与给定查询字符串相似的文档，你可以微调相似性搜索的这些参数：
-- `k`：一个整数，指定要返回的相似文档的最大数量。这通常被称为 “top K” 搜索或 “K最近邻”（KNN）。
-- `threshold`：一个值从 0 到 1 的双精度数，接近1的值表示更高的相似性。默认情况下，如果您设置了阈值为0.75，那么只有相似度超过此值的文档才会被返回。
-- `Filter.Expression`：一个用于传递流畅 DSL（特定域语言）表达式的类，其功能类似于 SQL 中的 “where”子句，但它仅适用于`Document`的元数据键值对。
-- `filterExpression`：基于 ANTLR4 的外部 DSL，接受字符串形式的过滤表达式。例如，对于元数据键如country、year 和`isActive`，您可以使用如下表达式：`country == 'UK' && year >= 2020 && isActive == true`。
-
-## 示例用法
-Spring AI Alibaba已经集成了`阿里云百炼平台`，接下来介绍基于阿里云百炼平台调用 VectorStore API。
-### 准备工作
-在开始之前，参考如下链接获取API-KEY：[获取API-KEY](https://help.aliyun.com/zh/model-studio/developer-reference/get-api-key)。
-然后，在项目环境中设置API-KEY，有两种方式：
-
-- 方式一：设置`configuration properties：spring.ai.dashscope.api-key` 为上述API-KEY。
-- 方式二：设置环境变量`export SPRING_AI_DASHSCOPE_API_KEY=<YOUR API  KEY>`
-### Auto-configuration
-Spring AI 为 VectorStore 提供了 Spring Boot 的自动配置。要启用此功能，请将以下依赖项添加到您项目的 Maven`pom.xml`文件中：
-```xml
-<dependency>
-    <groupId>org.springframework.ai</groupId>
-    <artifactId>spring-ai-dashscope-spring-boot-starter</artifactId>
-</dependency>
-```
-或者添加到您的Gradle`build.gradle`文件中：
-```gradle
-dependencies {
-    implementation 'org.springframework.ai:spring-ai-dashscope-spring-boot-starter'
-}
-```
-
-#### VectorStore Properties
-前缀`spring.ai.dashscope`是用于配置连接至 DashScope 的属性前缀。
-
-| Property                       | Action          | Default |
-|:-------------------------------|:----------------|---------|
-| `spring.ai.dashscope.api-key`  | 来自百炼平台的API KEY  | -       |
-
-```tips
-所有以 spring.ai.dashscope 开头的属性都可以在构造 DashScopeCloudStore 时传入Runtime Options来覆盖。
-```
-
-### Runtime Options
-`DashScopeStoreOptions`提供了 DashScopeCloudStore 的配置信息，它通过构造函数来创建选项。
-
-在构造`DashScopeCloudStore`时，通过将一个`DashScopeStoreOptions`实例传入，已完成配置。
-
-例如，使用指定的知识库：
-```java
-DashScopeCloudStore cloudStore = new DashScopeCloudStore(
-        dashscopeApi, new DashScopeStoreOptions("spring-ai知识库"));
-```
-### 示例代码
-该示例将创建一个`DashScopeCloudStore`实例，在指定的知识库上执行检索操作。以下是简单的`@Controller`类的示例，它使用了该 DashScopeCloudStore 实例。
-```properties
-spring.ai.dashscope.api-key=YOUR_API_KEY
-```
-```java
-@RestController
-public class StoreController {
-
-    private final DashScopeCloudStore dashScopeCloudStore;
-
-    @Autowired
-    public StoreController(DashScopeCloudStore dashScopeCloudStore) {
-        this.dashScopeCloudStore = dashScopeCloudStore;
-    }
-
-    @GetMapping("/ai/search")
-    public List<Document> store(@RequestParam(value = "message", defaultValue = "What's spring ai") String message) {
-        return this.dashScopeCloudStore.similaritySearch(message);
-    }
-}
-```
-### Manual Configuration
-如果您不希望使用 Spring Boot 的 Auto-configuration，可以在应用程序中手动配置`DashScopeCloudStore`。为此，请将`spring.ai.dashscope`依赖项添加到您项目的 Maven`pom.xml`文件中：
-```xml
-<dependency>
-    <groupId>org.springframework.ai</groupId>
-    <artifactId>spring-ai-dashscope</artifactId>
-</dependency>
-```
-
-或者添加到您的Gradle`build.gradle`文件中：
-```gradle
-dependencies {
-    implementation 'org.springframework.ai:spring-ai-dashscope'
-}
-```
-```note
-spring-ai-dashcope 依赖项还提供了对 DashScopeChatModel 的访问。有关 DashScopeChatModel 的更多信息，请参考 DashScope Chat Client部分。
-```
-
-接下来，创建一个`DashScopeCloudStore`实例，并使用它检索文档片段：
-```java
-DashScopeCloudStore cloudStore = new DashScopeCloudStore(
-        dashscopeApi, new DashScopeStoreOptions("spring-ai知识库"));
-
-List<Document> documentList = cloudStore.similaritySearch("What's spring ai");
-```
\ No newline at end of file
diff --git a/src/pages/ai/[...slug].astro b/src/pages/ai/[...slug].astro
deleted file mode 100644
index ca5725a40..000000000
--- a/src/pages/ai/[...slug].astro
+++ /dev/null
@@ -1,147 +0,0 @@
----
-import { type CollectionEntry, getCollection } from "astro:content";
-import BlogPost from "@components/markdownSet/MarkdownDetail.astro";
-import TocComponent from "@components/markdownSet/TocComponents/TocComponent.astro";
-import BaseLayout from "@layouts/BaseLayout.astro";
-import { Button } from "@serverless-cd/goat-ui";
-import { Icon } from "@astrojs/starlight/components";
-import Sidebar from "@components/starlight/Sidebar.astro";
-import { useTranslations } from "@i18n/util";
-import { SITE } from "@utils/config";
-import Pagination from "@astrojs/starlight/components/Pagination.astro";
-
-const t = useTranslations(Astro);
-
-export async function getStaticPaths() {
-	const posts = await getCollection("ai");
-	return posts.map((post) => ({
-		params: { slug: post.slug },
-		props: post,
-	}));
-}
-
-type Props = CollectionEntry<"ai">;
-
-const post = Astro.props;
-
-const { Content, headings } = await post.render();
-
-const posts = await getCollection("ai");
-
-const sortedPosts = posts.sort(
-	(a, b) => new Date(b.data.date).valueOf() - new Date(a.data.date).valueOf(),
-);
-
-const articlePosts = [
-	{
-		type: "group",
-		label: "Spring AI Alibaba",
-		entries: [],
-	},
-];
-
-let currentIndex;
-
-sortedPosts.forEach((item) => {
-	if (item.data.category === post.data.category) {
-		if (post.id === item.id) currentIndex = articlePosts[0].entries.length;
-		articlePosts[0].entries.push({
-			type: "link",
-			label: item.data.title,
-			href: `/ai/${item.slug}/`,
-			isCurrent: post.id === item.id,
-			attrs: {},
-		});
-	}
-});
-
-const prev = articlePosts[0].entries[currentIndex - 1];
-const next = articlePosts[0].entries[currentIndex + 1];
-const baseLayout_title = post?.data?.title || `${SITE.name} Blog`;
-const description = post?.data?.description || "";
----
-
-<span class="blog-slug-wrapper">
-	<BaseLayout 
-		align="docs" title={baseLayout_title} 
-		description={description}
-		showheader={false}
-	>
-		<div class="w-full">
-			<div
-				class="w-[20%] sidebar-content fixed overflow-auto h-full hidden 2xl:inline-block xl:inline-block lg:inline-block md:inline-block"
-			>
-				<Sidebar sidebar={articlePosts} />
-			</div>
-			<div
-				class="w-full 2xl:ml-[20%] xl:ml-[20%] lg:ml-[20%] md:ml-[20%] 2xl:w-[60%] xl:w-[60%] lg:w-[80%] md:w-[80%] inline-block"
-			>
-				<BlogPost {...post.data}>
-					<div style="min-height: calc(100vh - 17rem)">
-						<Content />
-					</div>
-				</BlogPost>
-				<nav class="pb-6">
-					{
-						(prev || next) && (
-							<Pagination
-								labels={{
-									"page.previousLink": t(
-										"commmon.base.page.previousLink",
-									),
-									"page.nextLink": t(
-										"commmon.base.page.nextLink",
-									),
-								}}
-								pagination={{
-									prev: prev,
-									next: next,
-								}}
-							/>
-						)
-					}
-				</nav>
-			</div>
-			<div
-				class="right-sidebar-panel w-[18%] fixed h-full hidden 2xl:inline-block xl:inline-block"
-			>
-				<TocComponent headings={headings} />
-			</div>
-		</div>
-	</BaseLayout>
-</span>
-
-
-<style is:global>
-	.blog-slug-wrapper {
-		.sidebar-content {
-			height: 100%;
-			padding: 1rem var(--sl-sidebar-pad-x) 0;
-			flex-direction: column;
-			gap: 1rem;
-		}
-		.right-sidebar-panel {
-			flex-direction: column;
-			justify-content: space-between;
-			height: calc(100vh - 3.5rem);
-			padding: 1rem var(--sl-sidebar-pad-x);
-		}
-		.right-sidebar-panel h2 {
-			color: var(--sl-color-white);
-			font-size: var(--sl-text-h5);
-			font-weight: 600;
-			line-height: var(--sl-line-height-headings);
-			margin-bottom: 0.5rem;
-		}
-		.right-sidebar-panel a {
-			display: block;
-			font-size: var(--sl-text-xs);
-			text-decoration: none;
-			color: var(--sl-color-gray-3);
-			overflow-wrap: anywhere;
-		}
-		.right-sidebar-panel a:hover {
-			color: var(--sl-color-white);
-		}
-	}
-</style>
diff --git a/src/pages/ai/index.astro b/src/pages/ai/index.astro
deleted file mode 100644
index c65e797b5..000000000
--- a/src/pages/ai/index.astro
+++ /dev/null
@@ -1,22 +0,0 @@
----
-import { useTranslations } from "@i18n/util";
-import BaseLayout from "@layouts/BaseLayout.astro";
-import HomeIntroduce from '@components/ai/HomeIntroduce.astro';
-import ChooseReason from '@/components/ai/CoreFeature.astro';
-import ArchitectureDiagram from '@components/ai/ArchitectureDiagram.astro';
-import HomeFooter from '@components/ai/Footer.astro';
-
-const t = useTranslations(Astro);
-
----
-
-<BaseLayout
-  title={t('home.title')}
-  description={t('home.description')}
-  showheader={false}
->
-    <HomeIntroduce/>
-    <ChooseReason />
-    <ArchitectureDiagram />
-    <HomeFooter />
-</BaseLayout>
\ No newline at end of file