Release 0.5.24 (#1178)

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

.changeset/odd-insects-vanish.md

@@ -1,5 +0,0 @@
----
-"@llamaindex/env": patch
----
-
-Use tiktoken instead of tiktoken/lite and disable WASM tiktoken for non-Node environments

.changeset/pink-keys-kiss.md

@@ -1,5 +0,0 @@
----
-"llamaindex": patch
----
-
-include node relationships when converting jsonToDoc

.eslintrc.cjs

@@ -31,7 +31,12 @@ module.exports = {
     "@typescript-eslint/ban-types": "off",
     "no-array-constructor": "off",
     "@typescript-eslint/no-array-constructor": "off",
-    "@typescript-eslint/no-base-to-string": "off",
+    "@typescript-eslint/no-base-to-string": [
+      "error",
+      {
+        ignoredTypeNames: ["Error", "RegExp", "URL", "URLSearchParams"],
+      },
+    ],
     "@typescript-eslint/no-duplicate-enum-values": "off",
     "@typescript-eslint/no-duplicate-type-constituents": "off",
     "@typescript-eslint/no-explicit-any": "off",

.github/workflows/lint_on_push_or_pull.yml

@@ -13,7 +13,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: pnpm/action-setup@v3
+      - uses: pnpm/action-setup@v4
       - name: Setup Node.js
         uses: actions/setup-node@v4
         with:

.github/workflows/preview.yml

@@ -0,0 +1,28 @@
+name: Publish Preview
+on: [pull_request]
+
+jobs:
+  pre_release:
+    name: Pre Release
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout Repo
+        uses: actions/checkout@v4
+
+      - uses: pnpm/action-setup@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version-file: ".nvmrc"
+          cache: "pnpm"
+
+      - name: Install dependencies
+        run: pnpm install
+
+      - name: Build
+        run: pnpm run build
+
+      - name: Pre Release
+        run: pnpx pkg-pr-new publish ./packages/*

.github/workflows/publish.yml

@@ -1,36 +0,0 @@
-name: Publish
-on:
-  push:
-    branches:
-      - main
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-
-    permissions:
-      contents: read
-      id-token: write
-
-    steps:
-      - uses: actions/checkout@v4
-      - uses: pnpm/action-setup@v3
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version-file: ".nvmrc"
-          cache: "pnpm"
-      - name: Install dependencies
-        run: pnpm install
-
-      - name: Publish @llamaindex/env
-        run: npx jsr publish
-        working-directory: packages/env
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Publish @llamaindex/core
-        run: npx jsr publish --allow-slow-types
-        working-directory: packages/llamaindex
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/publish_github.yml

@@ -12,7 +12,7 @@ jobs:
       - name: Checkout Repo
         uses: actions/checkout@v4
 
-      - uses: pnpm/action-setup@v3
+      - uses: pnpm/action-setup@v4
 
       - name: Setup Node.js
         uses: actions/setup-node@v4

.github/workflows/release.yml

@@ -15,7 +15,7 @@ jobs:
       - name: Checkout Repo
         uses: actions/checkout@v4
 
-      - uses: pnpm/action-setup@v3
+      - uses: pnpm/action-setup@v4
 
       - name: Setup Node.js
         uses: actions/setup-node@v4
@@ -55,3 +55,16 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+
+      # Refs: https://github.com/changesets/changesets/issues/421
+      - name: Update lock file
+        continue-on-error: true
+        run: pnpm install --lockfile-only
+
+      - name: Commit lock file
+        continue-on-error: true
+        uses: stefanzweifel/git-auto-commit-action@v5
+        with:
+          commit_message: "chore: update lock file"
+          branch: changeset-release/main
+          file_pattern: "pnpm-lock.yaml"

.github/workflows/test.yml

@@ -23,7 +23,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - uses: pnpm/action-setup@v3
+      - uses: pnpm/action-setup@v4
 
       - name: Setup Node.js
         uses: actions/setup-node@v4
@@ -45,7 +45,7 @@ jobs:
 
     steps:
       - uses: actions/checkout@v4
-      - uses: pnpm/action-setup@v3
+      - uses: pnpm/action-setup@v4
       - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
@@ -60,7 +60,7 @@ jobs:
 
     steps:
       - uses: actions/checkout@v4
-      - uses: pnpm/action-setup@v3
+      - uses: pnpm/action-setup@v4
       - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
@@ -91,12 +91,13 @@ jobs:
           - cloudflare-worker-agent
           - nextjs-agent
           - nextjs-edge-runtime
+          - nextjs-node-runtime
     #          - waku-query-engine
     runs-on: ubuntu-latest
     name: Build LlamaIndex Example (${{ matrix.packages }})
     steps:
       - uses: actions/checkout@v4
-      - uses: pnpm/action-setup@v3
+      - uses: pnpm/action-setup@v4
       - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
@@ -115,7 +116,7 @@ jobs:
 
     steps:
       - uses: actions/checkout@v4
-      - uses: pnpm/action-setup@v3
+      - uses: pnpm/action-setup@v4
       - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
@@ -127,6 +128,12 @@ jobs:
         run: pnpm run build
       - name: Copy examples
         run: rsync -rv --exclude=node_modules ./examples ${{ runner.temp }}
+      - name: Pack @llamaindex/cloud
+        run: pnpm pack --pack-destination ${{ runner.temp }}
+        working-directory: packages/cloud
+      - name: Pack @llamaindex/core
+        run: pnpm pack --pack-destination ${{ runner.temp }}
+        working-directory: packages/core
       - name: Pack @llamaindex/env
         run: pnpm pack --pack-destination ${{ runner.temp }}
         working-directory: packages/env

.gitignore

@@ -48,3 +48,6 @@ playwright/.cache/
 
 # intellij
 **/.idea
+
+# generated API
+packages/cloud/src/client

CONTRIBUTING.md

@@ -4,11 +4,11 @@
 
 This is a monorepo built with Turborepo
 
-Right now there are two packages of importance:
+Right now, for first-time contributors, these three packages are of the highest importance:
 
-packages/llamaindex which is the main NPM library llamaindex
-
-examples is where the demo code lives
+- `packages/llamaindex` which is the main NPM library `llamaindex`
+- `examples` is where the demo code lives
+- `apps/docs` is where the code for the documentation of https://ts.llamaindex.ai/ is located
 
 ### Turborepo docs
 
@@ -43,11 +43,11 @@ pnpm run test
 
 To write new test cases write them in [packages/llamaindex/tests](/packages/llamaindex/tests)
 
-We use Jest https://jestjs.io/ to write our test cases. Jest comes with a bunch of built in assertions using the expect function: https://jestjs.io/docs/expect
+We use Vitest https://vitest.dev to write our test cases. Vitest comes with a bunch of built-in assertions using the expect function: https://vitest.dev/api/expect.html#expect
 
 ### Demo applications
 
-There is an existing ["example"](/examples/README.md) demos folder with mainly NodeJS scripts. Feel free to add additional demos to that folder. If you would like to try out your changes in the core package with a new demo, you need to run the build command in the README.
+There is an existing ["example"](/examples/README.md) demos folder with mainly NodeJS scripts. Feel free to add additional demos to that folder. If you would like to try out your changes in the `llamaindex` package with a new demo, you need to run the build command in the README.
 
 You can create new demo applications in the apps folder. Just run pnpm init in the folder after you create it to create its own package.json
 
@@ -81,7 +81,7 @@ Any changes you make should be reflected in the browser. If you need to regenera
 
 ## Changeset
 
-We use [changesets](https://github.com/changesets/changesets) for managing versions and changelogs. To create a new changeset, run:
+We use [changesets](https://github.com/changesets/changesets) for managing versions and changelogs. To create a new changeset, run in the root folder:
 
 ```
 pnpm changeset

README.md

@@ -76,7 +76,7 @@ main();
 node --import tsx ./main.ts
 ```
 
-### Next.js
+### React Server Component (Next.js, Waku, Redwood.JS...)
 
 First, you will need to add a llamaindex plugin to your Next.js project.
 
@@ -154,40 +154,6 @@ export async function chatWithAgent(
 }
 ```
 
-### Cloudflare Workers
-
-```ts
-// src/index.ts
-export default {
-  async fetch(
-    request: Request,
-    env: Env,
-    ctx: ExecutionContext,
-  ): Promise<Response> {
-    const { setEnvs } = await import("@llamaindex/env");
-    // set environment variables so that the OpenAIAgent can use them
-    setEnvs(env);
-    const { OpenAIAgent } = await import("llamaindex");
-    const agent = new OpenAIAgent({
-      tools: [],
-    });
-    const responseStream = await agent.chat({
-      stream: true,
-      message: "Hello? What is the weather today?",
-    });
-    const textEncoder = new TextEncoder();
-    const response = responseStream.pipeThrough(
-      new TransformStream({
-        transform: (chunk, controller) => {
-          controller.enqueue(textEncoder.encode(chunk.response.delta));
-        },
-      }),
-    );
-    return new Response(response);
-  },
-};
-```
-
 ## Playground
 
 Check out our NextJS playground at https://llama-playground.vercel.app/. The source is available at https://github.com/run-llama/ts-playground
@@ -198,7 +164,7 @@ Check out our NextJS playground at https://llama-playground.vercel.app/. The sou
 
 - [Node](/packages/llamaindex/src/Node.ts): The basic data building block. Most commonly, these are parts of the document split into manageable pieces that are small enough to be fed into an embedding model and LLM.
 
-- [Embedding](/packages/llamaindex/src/embeddings/OpenAIEmbedding.ts): Embeddings are sets of floating point numbers which represent the data in a Node. By comparing the similarity of embeddings, we can derive an understanding of the similarity of two pieces of data. One use case is to compare the embedding of a question with the embeddings of our Nodes to see which Nodes may contain the data needed to answer that quesiton. Because the default service context is OpenAI, the default embedding is `OpenAIEmbedding`. If using different models, say through Ollama, use this [Embedding](/packages/llamaindex/src/embeddings/OllamaEmbedding.ts) (see all [here](/packages/llamaindex/src/embeddings)).
+- [Embedding](/packages/llamaindex/src/embeddings/OpenAIEmbedding.ts): Embeddings are sets of floating point numbers which represent the data in a Node. By comparing the similarity of embeddings, we can derive an understanding of the similarity of two pieces of data. One use case is to compare the embedding of a question with the embeddings of our Nodes to see which Nodes may contain the data needed to answer that question. Because the default service context is OpenAI, the default embedding is `OpenAIEmbedding`. If using different models, say through Ollama, use this [Embedding](/packages/llamaindex/src/embeddings/OllamaEmbedding.ts) (see all [here](/packages/llamaindex/src/embeddings)).
 
 - [Indices](/packages/llamaindex/src/indices/): Indices store the Nodes and the embeddings of those nodes. QueryEngines retrieve Nodes from these Indices using embedding similarity.
 

apps/docs/.changeset/tall-parents-add.md

@@ -0,0 +1,6 @@
+---
+"llamaindex": minor
+"docs": minor
+---
+
+Add deepseek llm class

apps/docs/CHANGELOG.md

@@ -1,5 +1,301 @@
 # docs
 
+## 0.0.65
+
+### Patch Changes
+
+- llamaindex@0.5.24
+
+## 0.0.64
+
+### Patch Changes
+
+- llamaindex@0.5.23
+
+## 0.0.63
+
+### Patch Changes
+
+- Updated dependencies [4648da6]
+  - llamaindex@0.5.22
+
+## 0.0.62
+
+### Patch Changes
+
+- Updated dependencies [ae1149f]
+- Updated dependencies [2411c9f]
+- Updated dependencies [e8f229c]
+- Updated dependencies [11b3856]
+- Updated dependencies [83d7f41]
+- Updated dependencies [0148354]
+- Updated dependencies [1711f6d]
+  - llamaindex@0.5.21
+
+## 0.0.61
+
+### Patch Changes
+
+- Updated dependencies [d9d6c56]
+- Updated dependencies [22ff486]
+- Updated dependencies [eed0b04]
+  - llamaindex@0.5.20
+
+## 0.0.60
+
+### Patch Changes
+
+- Updated dependencies [fcbf183]
+  - llamaindex@0.5.19
+
+## 0.0.59
+
+### Patch Changes
+
+- Updated dependencies [8b66cf4]
+  - llamaindex@0.5.18
+
+## 0.0.58
+
+### Patch Changes
+
+- Updated dependencies [c654398]
+  - llamaindex@0.5.17
+
+## 0.0.57
+
+### Patch Changes
+
+- Updated dependencies [58abc57]
+  - llamaindex@0.5.16
+
+## 0.0.56
+
+### Patch Changes
+
+- Updated dependencies [01c184c]
+- Updated dependencies [07a275f]
+  - llamaindex@0.5.15
+
+## 0.0.55
+
+### Patch Changes
+
+- Updated dependencies [c825a2f]
+  - llamaindex@0.5.14
+
+## 0.0.54
+
+### Patch Changes
+
+- llamaindex@0.5.13
+
+## 0.0.53
+
+### Patch Changes
+
+- Updated dependencies [345300f]
+- Updated dependencies [da5cfc4]
+- Updated dependencies [da5cfc4]
+  - llamaindex@0.5.12
+
+## 0.0.52
+
+### Patch Changes
+
+- 376d29a: feat: added tool calling and agent support for llama3.1 504B
+  - llamaindex@0.5.11
+
+## 0.0.51
+
+### Patch Changes
+
+- 086b940: feat: add DeepSeek LLM
+- 5d5716b: feat: add a reader for JSON data
+- Updated dependencies [086b940]
+- Updated dependencies [5d5716b]
+- Updated dependencies [91d02a4]
+- Updated dependencies [fb6db45]
+  - llamaindex@0.5.10
+
+## 0.0.50
+
+### Patch Changes
+
+- Updated dependencies [15962b3]
+  - llamaindex@0.5.9
+
+## 0.0.49
+
+### Patch Changes
+
+- Updated dependencies [3d5ba08]
+- Updated dependencies [d917cdc]
+  - llamaindex@0.5.8
+
+## 0.0.48
+
+### Patch Changes
+
+- Updated dependencies [ec59acd]
+  - llamaindex@0.5.7
+
+## 0.0.47
+
+### Patch Changes
+
+- Updated dependencies [2562244]
+- Updated dependencies [325aa51]
+- Updated dependencies [ab700ea]
+- Updated dependencies [92f0782]
+- Updated dependencies [6cf6ae6]
+- Updated dependencies [b7cfe5b]
+  - llamaindex@0.5.6
+
+## 0.0.46
+
+### Patch Changes
+
+- Updated dependencies [b974eea]
+  - llamaindex@0.5.5
+
+## 0.0.45
+
+### Patch Changes
+
+- Updated dependencies [1a65ead]
+  - llamaindex@0.5.4
+
+## 0.0.44
+
+### Patch Changes
+
+- Updated dependencies [9bbbc67]
+- Updated dependencies [b3681bf]
+  - llamaindex@0.5.3
+
+## 0.0.43
+
+### Patch Changes
+
+- llamaindex@0.5.2
+
+## 0.0.42
+
+### Patch Changes
+
+- 2774681: Add mixedbread's embeddings and reranking API
+- Updated dependencies [2774681]
+- Updated dependencies [a0f424e]
+  - llamaindex@0.5.1
+
+## 0.0.41
+
+### Patch Changes
+
+- 36ddec4: fix: typo in custom page separator parameter for LlamaParse
+- Updated dependencies [16ef5dd]
+- Updated dependencies [16ef5dd]
+- Updated dependencies [36ddec4]
+  - llamaindex@0.5.0
+  - @llamaindex/examples@0.0.7
+
+## 0.0.40
+
+### Patch Changes
+
+- llamaindex@0.4.14
+
+## 0.0.39
+
+### Patch Changes
+
+- Updated dependencies [e8f8bea]
+- Updated dependencies [304484b]
+  - llamaindex@0.4.13
+
+## 0.0.38
+
+### Patch Changes
+
+- Updated dependencies [f326ab8]
+  - llamaindex@0.4.12
+
+## 0.0.37
+
+### Patch Changes
+
+- Updated dependencies [8bf5b4a]
+  - llamaindex@0.4.11
+
+## 0.0.36
+
+### Patch Changes
+
+- Updated dependencies [7dce3d2]
+  - llamaindex@0.4.10
+
+## 0.0.35
+
+### Patch Changes
+
+- Updated dependencies [3a96a48]
+  - llamaindex@0.4.9
+
+## 0.0.34
+
+### Patch Changes
+
+- Updated dependencies [83ebdfb]
+  - llamaindex@0.4.8
+
+## 0.0.33
+
+### Patch Changes
+
+- Updated dependencies [41fe871]
+- Updated dependencies [321c39d]
+- Updated dependencies [f7f1af0]
+  - llamaindex@0.4.7
+
+## 0.0.32
+
+### Patch Changes
+
+- Updated dependencies [1feb23b]
+- Updated dependencies [08c55ec]
+  - llamaindex@0.4.6
+
+## 0.0.31
+
+### Patch Changes
+
+- Updated dependencies [6c3e5d0]
+  - llamaindex@0.4.5
+
+## 0.0.30
+
+### Patch Changes
+
+- Updated dependencies [42eb73a]
+  - llamaindex@0.4.4
+
+## 0.0.29
+
+### Patch Changes
+
+- Updated dependencies [2ef62a9]
+  - llamaindex@0.4.3
+  - @llamaindex/examples@0.0.6
+
+## 0.0.28
+
+### Patch Changes
+
+- Updated dependencies [a87a4d1]
+- Updated dependencies [0730140]
+  - llamaindex@0.4.2
+
 ## 0.0.27
 
 ### Patch Changes

apps/docs/docs/examples/agent_gemini.mdx

@@ -0,0 +1,6 @@
+# Gemini Agent
+
+import CodeBlock from "@theme/CodeBlock";
+import CodeSourceGemini from "!raw-loader!../../../../examples/gemini/agent.ts";
+
+<CodeBlock language="ts">{CodeSourceGemini}</CodeBlock>

apps/docs/docs/getting_started/concepts.md

@@ -62,7 +62,7 @@ These building blocks can be customized to reflect ranking preferences, as well
 
 [**Retrievers**](../modules/retriever.md):
 A retriever defines how to efficiently retrieve relevant context from a knowledge base (i.e. index) when given a query.
-The specific retrieval logic differs for difference indices, the most popular being dense retrieval against a vector index.
+The specific retrieval logic differs for different indices, the most popular being dense retrieval against a vector index.
 
 [**Response Synthesizers**](../modules/response_synthesizer.md):
 A response synthesizer generates a response from an LLM, using a user query and a given set of retrieved text chunks.

apps/docs/docs/getting_started/environments.md

@@ -6,10 +6,17 @@ sidebar_position: 2
 
 We support Node.JS versions 18, 20 and 22, with experimental support for Deno, Bun and Vercel Edge functions.
 
-## NextJS App Router
+## NextJS
 
-If you're using NextJS App Router route handlers/serverless functions, you'll need to use the NodeJS mode:
+If you're using NextJS you'll need to add `withLlamaIndex` to your `next.config.js` file. This will add the necessary configuration for included 3rd-party libraries to your build:
 
 ```js
-export const runtime = "nodejs"; // default
+// next.config.js
+const withLlamaIndex = require("llamaindex/next");
+
+module.exports = withLlamaIndex({
+  // your next.js config
+});
 ```
+
+For details, check the latest [withLlamaIndex](https://github.com/run-llama/LlamaIndexTS/blob/main/packages/llamaindex/src/next.ts) implementation.

apps/docs/docs/guides/agents/2_create_agent.mdx

@@ -50,10 +50,10 @@ We want to see what our agent is up to, so we're going to hook into some events
 
 ```javascript
 Settings.callbackManager.on("llm-tool-call", (event) => {
-  console.log(event.detail.payload);
+  console.log(event.detail);
 });
 Settings.callbackManager.on("llm-tool-result", (event) => {
-  console.log(event.detail.payload);
+  console.log(event.detail);
 });
 ```
 

apps/docs/docs/introduction.md

@@ -21,7 +21,7 @@ LlamaIndex.TS handles several major use cases:
 
 - **Structured Data Extraction**: turning complex, unstructured and semi-structured data into uniform, programmatically accessible formats.
 - **Retrieval-Augmented Generation (RAG)**: answering queries across your internal data by providing LLMs with up-to-date, semantically relevant context including Question and Answer systems and chat bots.
-- **Autonomous Agents**: building software that is capable of intelligently selecting and using tools to accomplish tasks in an interative, unsupervised manner.
+- **Autonomous Agents**: building software that is capable of intelligently selecting and using tools to accomplish tasks in an interactive, unsupervised manner.
 
 ## 👨‍👩‍👧‍👦 Who is LlamaIndex for?
 

apps/docs/docs/modules/agent/index.md

@@ -12,12 +12,15 @@ An “agent” is an automated reasoning and decision engine. It takes in a user
 LlamaIndex.TS comes with a few built-in agents, but you can also create your own. The built-in agents include:
 
 - OpenAI Agent
-- Anthropic Agent
+- Anthropic Agent both via Anthropic and Bedrock (in `@llamaIndex/community`)
+- Gemini Agent
 - ReACT Agent
+- Meta3.1 504B via Bedrock (in `@llamaIndex/community`)
 
 ## Examples
 
 - [OpenAI Agent](../../examples/agent.mdx)
+- [Gemini Agent](../../examples/agent_gemini.mdx)
 
 ## Api References
 

apps/docs/docs/modules/chat_engine.md

@@ -27,3 +27,4 @@ for await (const chunk of stream) {
 
 - [ContextChatEngine](../api/classes/ContextChatEngine.md)
 - [CondenseQuestionChatEngine](../api/classes/ContextChatEngine.md)
+- [SimpleChatEngine](../api/classes/SimpleChatEngine.md)

apps/docs/docs/modules/data_index.md

@@ -21,3 +21,4 @@ const index = await VectorStoreIndex.fromDocuments([document]);
 
 - [SummaryIndex](../api/classes/SummaryIndex.md)
 - [VectorStoreIndex](../api/classes/VectorStoreIndex.md)
+- [KeywordTableIndex](../api/classes/KeywordTableIndex.md)

apps/docs/docs/modules/data_loaders/discord.mdx

@@ -0,0 +1,34 @@
+import CodeBlock from "@theme/CodeBlock";
+import CodeSource from "!raw-loader!../../../../../examples/readers/src/discord";
+
+# DiscordReader
+
+DiscordReader is a simple data loader that reads all messages in a given Discord channel and returns them as Document objects.
+It uses the [@discordjs/rest](https://github.com/discordjs/discord.js/tree/main/packages/rest) library to fetch the messages.
+
+## Usage
+
+First step is to create a Discord Application and generating a bot token [here](https://discord.com/developers/applications).
+In your Discord Application, go to the `OAuth2` tab and generate an invite URL by selecting `bot` and click `Read Messages/View Channels` as wells as `Read Message History`.
+This will invite the bot with the necessary permissions to read messages.
+Copy the URL in your browser and select the server you want your bot to join.
+
+<CodeBlock language="ts">{CodeSource}</CodeBlock>
+
+### Params
+
+#### DiscordReader()
+
+- `discordToken?`: The Discord bot token.
+- `requestHandler?`: Optionally provide a custom request function for edge environments, e.g. `fetch`. See discord.js for more info.
+
+#### DiscordReader.loadData
+
+- `channelIDs`: The ID(s) of discord channels as an array of strings.
+- `limit?`: Optionally limit the number of messages to read
+- `additionalInfo?`: An optional flag to include embedded messages and attachment urls in the document.
+- `oldestFirst?`: An optional flag to return the oldest messages first.
+
+## API Reference
+
+- [DiscordReader](../../api/classes/DiscordReader.md)

apps/docs/docs/modules/data_loaders/index.mdx

@@ -16,7 +16,15 @@ It is a simple reader that reads all files from a directory and its subdirectori
 
 <CodeBlock language="ts">{CodeSource}</CodeBlock>
 
-Currently, it supports reading `.txt`, `.pdf`, `.csv`, `.md`, `.docx`, `.htm`, `.html`, `.jpg`, `.jpeg`, `.png` and `.gif` files, but support for other file types is planned.
+Currently, the following readers are mapped to specific file types:
+
+- [TextFileReader](../../api/classes/TextFileReader.md): `.txt`
+- [PDFReader](../../api/classes/PDFReader.md): `.pdf`
+- [PapaCSVReader](../../api/classes/PapaCSVReader.md): `.csv`
+- [MarkdownReader](../../api/classes/MarkdownReader.md): `.md`
+- [DocxReader](../../api/classes/DocxReader.md): `.docx`
+- [HTMLReader](../../api/classes/HTMLReader.md): `.htm`, `.html`
+- [ImageReader](../../api/classes/ImageReader.md): `.jpg`, `.jpeg`, `.png`, `.gif`
 
 You can modify the reader three different ways:
 

apps/docs/docs/modules/data_loaders/json.md

@@ -0,0 +1,149 @@
+# JSONReader
+
+A simple JSON data loader with various options.
+Either parses the entire string, cleaning it and treat each line as an embedding or performs a recursive depth-first traversal yielding JSON paths.
+Supports streaming of large JSON data using [@discoveryjs/json-ext](https://github.com/discoveryjs/json-ext)
+
+## Usage
+
+```ts
+import { JSONReader } from "llamaindex";
+
+const file = "../../PATH/TO/FILE";
+const content = new TextEncoder().encode("JSON_CONTENT");
+
+const reader = new JSONReader({ levelsBack: 0, collapseLength: 100 });
+const docsFromFile = reader.loadData(file);
+const docsFromContent = reader.loadDataAsContent(content);
+```
+
+### Options
+
+Basic:
+
+- `streamingThreshold?`: The threshold for using streaming mode in MB of the JSON Data. CEstimates characters by calculating bytes: `(streamingThreshold * 1024 * 1024) / 2` and comparing against `.length` of the JSON string. Set `undefined` to disable streaming or `0` to always use streaming. Default is `50` MB.
+
+- `ensureAscii?`: Wether to ensure only ASCII characters be present in the output by converting non-ASCII characters to their unicode escape sequence. Default is `false`.
+
+- `isJsonLines?`: Wether the JSON is in JSON Lines format. If true, will split into lines, remove empty one and parse each line as JSON. Note: Uses a custom streaming parser, most likely less robust than json-ext. Default is `false`
+
+- `cleanJson?`: Whether to clean the JSON by filtering out structural characters (`{}, [], and ,`). If set to false, it will just parse the JSON, not removing structural characters. Default is `true`.
+
+- `logger?`: A placeholder for a custom logger function.
+
+Depth-First-Traversal:
+
+- `levelsBack?`: Specifies how many levels up the JSON structure to include in the output. `cleanJson` will be ignored. If set to 0, all levels are included. If undefined, parses the entire JSON, treat each line as an embedding and create a document per top-level array. Default is `undefined`
+
+- `collapseLength?`: The maximum length of JSON string representation to be collapsed into a single line. Only applicable when `levelsBack` is set. Default is `undefined`
+
+#### Examples
+
+<!-- prettier-ignore-start -->
+Input:
+
+```json
+{"a": {"1": {"key1": "value1"}, "2": {"key2": "value2"}}, "b": {"3": {"k3": "v3"}, "4": {"k4": "v4"}}}
+```
+
+Default options:
+
+`LevelsBack` = `undefined` & `cleanJson` = `true`
+
+Output:
+
+```json
+"a": {
+"1": {
+"key1": "value1"
+"2": {
+"key2": "value2"
+"b": {
+"3": {
+"k3": "v3"
+"4": {
+"k4": "v4"
+```
+
+Depth-First Traversal all levels:
+
+`levelsBack` = `0`
+
+Output:
+
+```json
+a 1 key1 value1
+a 2 key2 value2
+b 3 k3 v3
+b 4 k4 v4
+```
+
+Depth-First Traversal and Collapse:
+
+`levelsBack` = `0` & `collapseLength` = `35`
+
+Output:
+
+```json
+a 1 {"key1":"value1"}
+a 2 {"key2":"value2"}
+b {"3":{"k3":"v3"},"4":{"k4":"v4"}}
+```
+
+Depth-First Traversal limited levels:
+
+`levelsBack` = `2`
+
+Output:
+
+```json
+1 key1 value1
+2 key2 value2
+3 k3 v3
+4 k4 v4
+```
+
+Uncleaned JSON:
+
+`levelsBack` = `undefined` & `cleanJson` = `false`
+
+Output:
+
+```json
+{"a":{"1":{"key1":"value1"},"2":{"key2":"value2"}},"b":{"3":{"k3":"v3"},"4":{"k4":"v4"}}}
+```
+
+ASCII-Conversion:
+
+Input:
+
+```json
+{ "message": "こんにちは世界" }
+```
+
+Output:
+
+```json
+"message": "\u3053\u3093\u306b\u3061\u306f\u4e16\u754c"
+```
+
+JSON Lines Format:
+
+Input:
+
+```json
+{"tweet": "Hello world"}\n{"tweet": "こんにちは世界"}
+```
+
+Output:
+
+```json
+"tweet": "Hello world"
+
+"tweet": "こんにちは世界"
+```
+<!-- prettier-ignore-end -->
+
+## API Reference
+
+- [JSONReader](../../api/classes/JSONReader.md)

apps/docs/docs/modules/data_loaders/llama_parse/index.mdx

@@ -27,23 +27,31 @@ They can be divided into two groups.
 
 - `apiKey` is required. Can be set as an environment variable `LLAMA_CLOUD_API_KEY`
 - `checkInterval` is the interval in seconds to check if the parsing is done. Default is `1`.
-- `maxTimeout` is the maximum timout to wait for parsing to finish. Default is `2000`
+- `maxTimeout` is the maximum timeout to wait for parsing to finish. Default is `2000`
 - `verbose` shows progress of the parsing. Default is `true`
 - `ignoreErrors` set to false to get errors while parsing. Default is `true` and returns an empty array on error.
 
 #### Advanced params:
 
 - `resultType` can be set to `markdown`, `text` or `json`. Defaults to `text`. More information about `json` mode on the next pages.
-- `language` primarly helps with OCR recognition. Defaults to `en`. Click [here](../../../api/type-aliases/Language.md) for a list of supported languages.
+- `language` primarily helps with OCR recognition. Defaults to `en`. Click [here](../../../api/type-aliases/Language.md) for a list of supported languages.
 - `parsingInstructions?` Optional. Can help with complicated document structures. See this [LlamaIndex Blog Post](https://www.llamaindex.ai/blog/launching-the-first-genai-native-document-parsing-platform) for an example.
 - `skipDiagonalText?` Optional. Set to true to ignore diagonal text. (Text that is not rotated 0, 90, 180 or 270 degrees)
 - `invalidateCache?` Optional. Set to true to ignore the LlamaCloud cache. All document are kept in cache for 48hours after the job was completed to avoid processing the same document twice. Can be useful for testing when trying to re-parse the same document with, e.g. different `parsingInstructions`.
 - `doNotCache?` Optional. Set to true to not cache the document.
 - `fastMode?` Optional. Set to true to use the fast mode. This mode will skip OCR of images, and table/heading reconstruction. Note: Non-compatible with `gpt4oMode`.
-- `doNotUnrollColumns?` Optional. Set to true to keep the text according to document layout. Reduce reconstruction accuracy, and LLM's/embedings performances in most cases.
-- `pageSeperator?` Optional. The page seperator to use. Defaults is `\\n---\\n`.
-- `gpt4oMode` set to true to use GPT-4o to extract content. Default is `false`.
-- `gpt4oApiKey?` Optional. Set the GPT-4o API key. Lowers the cost of parsing by using your own API key. Your OpenAI account will be charged. Can also be set in the environment variable `LLAMA_CLOUD_GPT4O_API_KEY`.
+- `doNotUnrollColumns?` Optional. Set to true to keep the text according to document layout. Reduce reconstruction accuracy, and LLMs/embeddings performances in most cases.
+- `pageSeparator?` Optional. A templated page separator to use to split the text. If the results contain `{page_number}` (e.g. JSON mode), it will be replaced by the next page number. If not set the default separator `\\n---\\n` will be used.
+- `pagePrefix?` Optional. A templated prefix to add to the beginning of each page. If the results contain `{page_number}`, it will be replaced by the page number.
+- `pageSuffix?` Optional. A templated suffix to add to the end of each page. If the results contain `{page_number}`, it will be replaced by the page number.
+- `gpt4oMode` Deprecated. Use vendorMultimodal params. Set to true to use GPT-4o to extract content. Default is `false`.
+- `gpt4oApiKey?` Deprecated. Use vendorMultimodal params. Optional. Set the GPT-4o API key. Lowers the cost of parsing by using your own API key. Your OpenAI account will be charged. Can also be set in the environment variable `LLAMA_CLOUD_GPT4O_API_KEY`.
+- `boundingBox?` Optional. Specify an area of the document to parse. Expects the bounding box margins as a string in clockwise order, e.g. `boundingBox = "0.1,0,0,0"` to not parse the top 10% of the document.
+- `targetPages?` Optional. Specify which pages to parse by specifying them as a comma-separated list. First page is `0`.
+- `splitByPage` Wether to split the results, creating one document per page. Uses the set `pageSeparator` or `\n---\n` as fallback. Default is true.
+- `useVendorMultimodalModel` set to true to use a multimodal model. Default is `false`.
+- `vendorMultimodalModel?` Optional. Specify which multimodal model to use. Default is GPT4o. See [here](https://docs.cloud.llamaindex.ai/llamaparse/features/multimodal) for a list of available models and cost.
+- `vendorMultimodalApiKey?` Optional. Set the multimodal model API key. Can also be set in the environment variable `LLAMA_CLOUD_VENDOR_MULTIMODAL_API_KEY`.
 - `numWorkers` as in the python version, is set in `SimpleDirectoryReader`. Default is 1.
 
 ### LlamaParse with SimpleDirectoryReader

apps/docs/docs/modules/data_loaders/llama_parse/json_mode.mdx

@@ -8,7 +8,7 @@ In JSON mode, LlamaParse will return a data structure representing the parsed ob
 
 ## Usage
 
-For Json mode, you need to use `loadJson`. The `resultType` is automatically set with this method. Currently it can't be used with `SimpleDirectoryReader`.
+For Json mode, you need to use `loadJson`. The `resultType` is automatically set with this method.
 More information about indexing the results on the next page.
 
 ```ts
@@ -54,6 +54,42 @@ Within page objects, the following keys may be present depending on your documen
 - `images`: Any images extracted from the page.
 - `items`: An array of heading, text and table objects in the order they appear on the page.
 
+### JSON Mode with SimpleDirectoryReader
+
+All Readers share a `loadData` method with `SimpleDirectoryReader` that promises to return a uniform Document with Metadata. This makes JSON mode incompatible with SimpleDirectoryReader.
+
+However, a simple work around is to create a new reader class that extends `LlamaParseReader` and adds a new method or overrides `loadData`, wrapping around JSON mode, extracting the required values, and returning a Document object.
+
+```ts
+import { LlamaParseReader, Document } from "llamaindex";
+
+class LlamaParseReaderWithJson extends LlamaParseReader {
+  // Override the loadData method
+  override async loadData(filePath: string): Promise<Document[]> {
+    // Call loadJson method that was inherited by LlamaParseReader
+    const jsonObjs = await super.loadJson(filePath);
+    let documents: Document[] = [];
+
+    jsonObjs.forEach((jsonObj) => {
+      // Making sure it's an array before iterating over it
+      if (Array.isArray(jsonObj.pages)) {
+      }
+      const docs = jsonObj.pages.map(
+        (page: { text: string; page: number }) =>
+          new Document({ text: page.text, metadata: { page: page.page } }),
+      );
+      documents = documents.concat(docs);
+    });
+    return documents;
+  }
+}
+```
+
+Now we have documents with page number as metadata. This new reader can be used like any other and be integrated with SimpleDirectoryReader. Since it extends `LlamaParseReader`, you can use the same params.
+
+You can assign any other values of the JSON response to the Document as needed.
+
 ## API Reference
 
 - [LlamaParseReader](../../../api/classes/LlamaParseReader.md)
+- [SimpleDirectoryReader](../../../api/classes/SimpleDirectoryReader.md)

apps/docs/docs/modules/embeddings/available_embeddings/mixedbreadai.md

@@ -0,0 +1,104 @@
+# MixedbreadAI
+
+Welcome to the mixedbread embeddings guide! This guide will help you use the mixedbread ai's API to generate embeddings for your text documents, ensuring you get the most relevant information, just like picking the freshest bread from the bakery.
+
+To find out more about the latest features, updates, and available models, visit [mixedbread.ai](https://mixedbread-ai.com/).
+
+## Table of Contents
+
+1. [Setup](#setup)
+2. [Usage with LlamaIndex](#integration-with-llamaindex)
+3. [Embeddings with Custom Parameters](#embeddings-with-custom-parameters)
+
+## Setup
+
+First, you will need to install the `llamaindex` package.
+
+```bash
+pnpm install llamaindex
+```
+
+Next, sign up for an API key at [mixedbread.ai](https://mixedbread.ai/). Once you have your API key, you can import the necessary modules and create a new instance of the `MixedbreadAIEmbeddings` class.
+
+```ts
+import { MixedbreadAIEmbeddings, Document, Settings } from "llamaindex";
+```
+
+## Usage with LlamaIndex
+
+This section will guide you through integrating mixedbread embeddings with LlamaIndex for more advanced usage.
+
+### Step 1: Load and Index Documents
+
+For this example, we will use a single document. In a real-world scenario, you would have multiple documents to index, like a variety of breads in a bakery.
+
+```ts
+Settings.embedModel = new MixedbreadAIEmbeddings({
+  apiKey: "<MIXEDBREAD_API_KEY>",
+  model: "mixedbread-ai/mxbai-embed-large-v1",
+});
+
+const document = new Document({
+  text: "The true source of happiness.",
+  id_: "bread",
+});
+
+const index = await VectorStoreIndex.fromDocuments([document]);
+```
+
+### Step 2: Create a Query Engine
+
+Combine the retriever and the embed model to create a query engine. This setup ensures that your queries are processed to provide the best results, like arranging the bread in the order of freshness and quality.
+
+Models can require prompts to generate embeddings for queries, in the 'mixedbread-ai/mxbai-embed-large-v1' model's case, the prompt is `Represent this sentence for searching relevant passages:`.
+
+```ts
+const queryEngine = index.asQueryEngine();
+
+const query =
+  "Represent this sentence for searching relevant passages: What is bread?";
+
+// Log the response
+const results = await queryEngine.query(query);
+console.log(results); // Serving up the freshest, most relevant results.
+```
+
+## Embeddings with Custom Parameters
+
+This section will guide you through generating embeddings with custom parameters and usage with f.e. matryoshka and binary embeddings.
+
+### Step 1: Create an Instance of MixedbreadAIEmbeddings
+
+Create a new instance of the `MixedbreadAIEmbeddings` class with custom parameters. For example, to use the `mixedbread-ai/mxbai-embed-large-v1` model with a batch size of 64, normalized embeddings, and binary encoding format:
+
+```ts
+const embeddings = new MixedbreadAIEmbeddings({
+  apiKey: "<MIXEDBREAD_API_KEY>",
+  model: "mixedbread-ai/mxbai-embed-large-v1",
+  batchSize: 64,
+  normalized: true,
+  dimensions: 512,
+  encodingFormat: MixedbreadAI.EncodingFormat.Binary,
+});
+```
+
+### Step 2: Define Texts
+
+Define the texts you want to generate embeddings for.
+
+```ts
+const texts = ["Bread is life", "Bread is love"];
+```
+
+### Step 3: Generate Embeddings
+
+Use the `embedDocuments` method to generate embeddings for the texts.
+
+```ts
+const result = await embeddings.embedDocuments(texts);
+console.log(result); // Perfectly customized embeddings, ready to serve.
+```
+
+## API Reference
+
+- [MixedbreadAIEmbeddings](../../../api/classes/MixedbreadAIEmbeddings.md)

apps/docs/docs/modules/evaluation/index.md

@@ -2,7 +2,7 @@
 
 ## Concept
 
-Evaluation and benchmarking are crucial concepts in LLM development. To improve the perfomance of an LLM app (RAG, agents) you must have a way to measure it.
+Evaluation and benchmarking are crucial concepts in LLM development. To improve the performance of an LLM app (RAG, agents) you must have a way to measure it.
 
 LlamaIndex offers key modules to measure the quality of generated results. We also offer key modules to measure retrieval quality.
 

apps/docs/docs/modules/ingestion_pipeline/index.md

@@ -16,7 +16,7 @@ import {
   MetadataMode,
   OpenAIEmbedding,
   TitleExtractor,
-  SimpleNodeParser,
+  SentenceSplitter,
 } from "llamaindex";
 
 async function main() {
@@ -29,7 +29,7 @@ async function main() {
   const document = new Document({ text: essay, id_: path });
   const pipeline = new IngestionPipeline({
     transformations: [
-      new SimpleNodeParser({ chunkSize: 1024, chunkOverlap: 20 }),
+      new SentenceSplitter({ chunkSize: 1024, chunkOverlap: 20 }),
       new TitleExtractor(),
       new OpenAIEmbedding(),
     ],
@@ -62,7 +62,7 @@ import {
   MetadataMode,
   OpenAIEmbedding,
   TitleExtractor,
-  SimpleNodeParser,
+  SentenceSplitter,
   QdrantVectorStore,
   VectorStoreIndex,
 } from "llamaindex";
@@ -81,7 +81,7 @@ async function main() {
   const document = new Document({ text: essay, id_: path });
   const pipeline = new IngestionPipeline({
     transformations: [
-      new SimpleNodeParser({ chunkSize: 1024, chunkOverlap: 20 }),
+      new SentenceSplitter({ chunkSize: 1024, chunkOverlap: 20 }),
       new TitleExtractor(),
       new OpenAIEmbedding(),
     ],

apps/docs/docs/modules/ingestion_pipeline/transformations.md

@@ -4,7 +4,7 @@ A transformation is something that takes a list of nodes as an input, and return
 
 Currently, the following components are Transformation objects:
 
-- [SimpleNodeParser](../../api/classes/SimpleNodeParser.md)
+- [SentenceSplitter](../../api/classes/SentenceSplitter.md)
 - [MetadataExtractor](../documents_and_nodes/metadata_extraction.md)
 - [Embeddings](../embeddings/index.md)
 
@@ -13,10 +13,10 @@ Currently, the following components are Transformation objects:
 While transformations are best used with with an IngestionPipeline, they can also be used directly.
 
 ```ts
-import { SimpleNodeParser, TitleExtractor, Document } from "llamaindex";
+import { SentenceSplitter, TitleExtractor, Document } from "llamaindex";
 
 async function main() {
-  let nodes = new SimpleNodeParser().getNodesFromDocuments([
+  let nodes = new SentenceSplitter().getNodesFromDocuments([
     new Document({ text: "I am 10 years old. John is 20 years old." }),
   ]);
 
@@ -34,15 +34,15 @@ main().catch(console.error);
 
 ## Custom Transformations
 
-You can implement any transformation yourself by implementing the `TransformerComponent`.
+You can implement any transformation yourself by implementing the `TransformComponent`.
 
-The following custom transformation will remove any special characters or punctutaion in text.
+The following custom transformation will remove any special characters or punctuation in text.
 
 ```ts
-import { TransformerComponent, Node } from "llamaindex";
+import { TransformComponent, TextNode } from "llamaindex";
 
-class RemoveSpecialCharacters extends TransformerComponent {
-  async transform(nodes: Node[]): Promise<Node[]> {
+export class RemoveSpecialCharacters extends TransformComponent {
+  async transform(nodes: TextNode[]): Promise<TextNode[]> {
     for (const node of nodes) {
       node.text = node.text.replace(/[^\w\s]/gi, "");
     }
@@ -75,3 +75,7 @@ async function main() {
 
 main().catch(console.error);
 ```
+
+## API Reference
+
+- [TransformComponent](../../api/classes/TransformComponent.md)

apps/docs/docs/modules/llms/available_llms/bedrock.md

@@ -15,7 +15,7 @@ Settings.llm = new Bedrock({
 });
 ```
 
-Currently only supports Anthropic models:
+Currently only supports Anthropic and Meta models:
 
 ```ts
 ANTHROPIC_CLAUDE_INSTANT_1 = "anthropic.claude-instant-v1";
@@ -25,6 +25,13 @@ ANTHROPIC_CLAUDE_3_SONNET = "anthropic.claude-3-sonnet-20240229-v1:0";
 ANTHROPIC_CLAUDE_3_HAIKU = "anthropic.claude-3-haiku-20240307-v1:0";
 ANTHROPIC_CLAUDE_3_OPUS = "anthropic.claude-3-opus-20240229-v1:0"; // available on us-west-2
 ANTHROPIC_CLAUDE_3_5_SONNET = "anthropic.claude-3-5-sonnet-20240620-v1:0";
+META_LLAMA2_13B_CHAT = "meta.llama2-13b-chat-v1";
+META_LLAMA2_70B_CHAT = "meta.llama2-70b-chat-v1";
+META_LLAMA3_8B_INSTRUCT = "meta.llama3-8b-instruct-v1:0";
+META_LLAMA3_70B_INSTRUCT = "meta.llama3-70b-instruct-v1:0";
+META_LLAMA3_1_8B_INSTRUCT = "meta.llama3-1-8b-instruct-v1:0"; // available on us-west-2
+META_LLAMA3_1_70B_INSTRUCT = "meta.llama3-1-70b-instruct-v1:0"; // available on us-west-2
+META_LLAMA3_1_405B_INSTRUCT = "meta.llama3-1-405b-instruct-v1:0"; // preview only, available on us-west-2, tool calling supported
 ```
 
 Sonnet, Haiku and Opus are multimodal, image_url only supports base64 data url format, e.g. `data:image/jpeg;base64,SGVsbG8sIFdvcmxkIQ==`
@@ -60,3 +67,72 @@ async function main() {
   console.log(response.response);
 }
 ```
+
+## Agent Example
+
+```ts
+import { BEDROCK_MODELS, Bedrock } from "@llamaindex/community";
+import { FunctionTool, LLMAgent } from "llamaindex";
+
+const sumNumbers = FunctionTool.from(
+  ({ a, b }: { a: number; b: number }) => `${a + b}`,
+  {
+    name: "sumNumbers",
+    description: "Use this function to sum two numbers",
+    parameters: {
+      type: "object",
+      properties: {
+        a: {
+          type: "number",
+          description: "The first number",
+        },
+        b: {
+          type: "number",
+          description: "The second number",
+        },
+      },
+      required: ["a", "b"],
+    },
+  },
+);
+
+const divideNumbers = FunctionTool.from(
+  ({ a, b }: { a: number; b: number }) => `${a / b}`,
+  {
+    name: "divideNumbers",
+    description: "Use this function to divide two numbers",
+    parameters: {
+      type: "object",
+      properties: {
+        a: {
+          type: "number",
+          description: "The dividend a to divide",
+        },
+        b: {
+          type: "number",
+          description: "The divisor b to divide by",
+        },
+      },
+      required: ["a", "b"],
+    },
+  },
+);
+
+const bedrock = new Bedrock({
+  model: BEDROCK_MODELS.META_LLAMA3_1_405B_INSTRUCT,
+  ...
+});
+
+async function main() {
+  const agent = new LLMAgent({
+    llm: bedrock,
+    tools: [sumNumbers, divideNumbers],
+  });
+
+  const response = await agent.chat({
+    message: "How much is 5 + 5? then divide by 2",
+  });
+
+  console.log(response.message);
+}
+```

apps/docs/docs/modules/llms/available_llms/deepseek.md

@@ -0,0 +1,52 @@
+# DeepSeek LLM
+
+[DeepSeek Platform](https://platform.deepseek.com/)
+
+## Usage
+
+```ts
+import { DeepSeekLLM, Settings } from "llamaindex";
+
+Settings.llm = new DeepSeekLLM({
+  apiKey: "<YOUR_API_KEY>",
+  model: "deepseek-coder", // or "deepseek-chat"
+});
+```
+
+## Example
+
+```ts
+import { DeepSeekLLM, Document, VectorStoreIndex, Settings } from "llamaindex";
+
+const deepseekLlm = new DeepSeekLLM({
+  apiKey: "<YOUR_API_KEY>",
+  model: "deepseek-coder", // or "deepseek-chat"
+});
+
+async function main() {
+  const response = await llm.deepseekLlm.chat({
+    messages: [
+      {
+        role: "system",
+        content: "You are an AI assistant",
+      },
+      {
+        role: "user",
+        content: "Tell me about San Francisco",
+      },
+    ],
+    stream: false,
+  });
+  console.log(response);
+}
+```
+
+# Limitations
+
+Currently does not support function calling.
+
+[Currently does not support json-output param while still is very good at json generating.](https://platform.deepseek.com/api-docs/faq#does-your-api-support-json-output)
+
+## API Reference
+
+- [DeepSeekLLM](../../../api/classes/DeepSeekLLM.md)

apps/docs/docs/modules/node_parser.md

@@ -7,9 +7,9 @@ sidebar_position: 4
 The `NodeParser` in LlamaIndex is responsible for splitting `Document` objects into more manageable `Node` objects. When you call `.fromDocuments()`, the `NodeParser` from the `Settings` is used to do this automatically for you. Alternatively, you can use it to split documents ahead of time.
 
 ```typescript
-import { Document, SimpleNodeParser } from "llamaindex";
+import { Document, SentenceSplitter } from "llamaindex";
 
-const nodeParser = new SimpleNodeParser();
+const nodeParser = new SentenceSplitter();
 
 Settings.nodeParser = nodeParser;
 ```
@@ -93,6 +93,5 @@ The output metadata will be something like:
 
 ## API Reference
 
-- [SimpleNodeParser](../api/classes/SimpleNodeParser.md)
 - [SentenceSplitter](../api/classes/SentenceSplitter.md)
 - [MarkdownNodeParser](../api/classes/MarkdownNodeParser.md)

apps/docs/docs/modules/node_postprocessors/cohere_reranker.md

@@ -39,8 +39,9 @@ const index = await VectorStoreIndex.fromDocuments([document]);
 The default value for `similarityTopK` is 2. This means that only the most similar document will be returned. To retrieve more results, you can increase the value of `similarityTopK`.
 
 ```ts
-const retriever = index.asRetriever();
-retriever.similarityTopK = 5;
+const retriever = index.asRetriever({
+  similarityTopK: 5,
+});
 ```
 
 ## Create a new instance of the CohereRerank class

apps/docs/docs/modules/node_postprocessors/jinaai_reranker.md

@@ -39,8 +39,9 @@ const index = await VectorStoreIndex.fromDocuments([document]);
 The default value for `similarityTopK` is 2. This means that only the most similar document will be returned. To retrieve more results, you can increase the value of `similarityTopK`.
 
 ```ts
-const retriever = index.asRetriever();
-retriever.similarityTopK = 5;
+const retriever = index.asRetriever({
+  similarityTopK: 5,
+});
 ```
 
 ## Create a new instance of the JinaAIReranker class

apps/docs/docs/modules/node_postprocessors/mixedbreadiai_reranker.md

@@ -0,0 +1,169 @@
+# MixedbreadAI
+
+Welcome to the mixedbread ai reranker guide! This guide will help you use mixedbread ai's API to rerank search query results, ensuring you get the most relevant information, just like picking the freshest bread from the bakery.
+
+To find out more about the latest features and updates, visit the [mixedbread.ai](https://mixedbread.ai/).
+
+## Table of Contents
+
+1. [Setup](#setup)
+2. [Usage with LlamaIndex](#integration-with-llamaindex)
+3. [Simple Reranking Guide](#simple-reranking-guide)
+4. [Reranking with Objects](#reranking-with-objects)
+
+## Setup
+
+First, you will need to install the `llamaindex` package.
+
+```bash
+pnpm install llamaindex
+```
+
+Next, sign up for an API key at [mixedbread.ai](https://mixedbread.ai/). Once you have your API key, you can import the necessary modules and create a new instance of the `MixedbreadAIReranker` class.
+
+```ts
+import {
+  MixedbreadAIReranker,
+  Document,
+  OpenAI,
+  VectorStoreIndex,
+  Settings,
+} from "llamaindex";
+```
+
+## Usage with LlamaIndex
+
+This section will guide you through integrating mixedbread's reranker with LlamaIndex.
+
+### Step 1: Load and Index Documents
+
+For this example, we will use a single document. In a real-world scenario, you would have multiple documents to index, like a variety of breads in a bakery.
+
+```ts
+const document = new Document({
+  text: "This is a sample document.",
+  id_: "sampleDoc",
+});
+
+Settings.llm = new OpenAI({ model: "gpt-3.5-turbo", temperature: 0.1 });
+
+const index = await VectorStoreIndex.fromDocuments([document]);
+```
+
+### Step 2: Increase Similarity TopK
+
+The default value for `similarityTopK` is 2, which means only the most similar document will be returned. To get more results, like picking a variety of fresh breads, you can increase the value of `similarityTopK`.
+
+```ts
+const retriever = index.asRetriever({
+  similarityTopK: 5,
+});
+```
+
+### Step 3: Create a MixedbreadAIReranker Instance
+
+Create a new instance of the `MixedbreadAIReranker` class.
+
+```ts
+const nodePostprocessor = new MixedbreadAIReranker({
+  apiKey: "<MIXEDBREAD_API_KEY>",
+  topN: 4,
+});
+```
+
+### Step 4: Create a Query Engine
+
+Combine the retriever and node postprocessor to create a query engine. This setup ensures that your queries are processed and reranked to provide the best results, like arranging the bread in the order of freshness and quality.
+
+```ts
+const queryEngine = index.asQueryEngine({
+  retriever,
+  nodePostprocessors: [nodePostprocessor],
+});
+
+// Log the response
+const response = await queryEngine.query("Where did the author grow up?");
+console.log(response);
+```
+
+With mixedbread's Reranker, you're all set to serve up the most relevant and well-ordered results, just like a skilled baker arranging their best breads for eager customers. Enjoy the perfect blend of technology and culinary delight!
+
+## Simple Reranking Guide
+
+This section will guide you through a simple reranking process using mixedbread ai.
+
+### Step 1: Create an Instance of MixedbreadAIReranker
+
+Create a new instance of the `MixedbreadAIReranker` class, passing in your API key and the number of results you want to return. It's like setting up your bakery to offer a specific number of freshly baked items.
+
+```ts
+const reranker = new MixedbreadAIReranker({
+  apiKey: "<MIXEDBREAD_API_KEY>",
+  topN: 4,
+});
+```
+
+### Step 2: Define Nodes and Query
+
+Define the nodes (documents) you want to rerank and the query.
+
+```ts
+const nodes = [
+  { node: new BaseNode("To bake bread you need flour") },
+  { node: new BaseNode("To bake bread you need yeast") },
+];
+const query = "What do you need to bake bread?";
+```
+
+### Step 3: Perform Reranking
+
+Use the `postprocessNodes` method to rerank the nodes based on the query.
+
+```ts
+const result = await reranker.postprocessNodes(nodes, query);
+console.log(result); // Like pulling freshly baked nodes out of the oven.
+```
+
+## Reranking with Objects
+
+This section will guide you through reranking when working with objects.
+
+### Step 1: Create an Instance of MixedbreadAIReranker
+
+Create a new instance of the `MixedbreadAIReranker` class, just like before.
+
+```ts
+const reranker = new MixedbreadAIReranker({
+  apiKey: "<MIXEDBREAD_API_KEY>",
+  model: "mixedbread-ai/mxbai-rerank-large-v1",
+  topK: 5,
+  rankFields: ["title", "content"],
+  returnInput: true,
+  maxRetries: 5,
+});
+```
+
+### Step 2: Define Documents and Query
+
+Define the documents (objects) you want to rerank and the query.
+
+```ts
+const documents = [
+  { title: "Bread Recipe", content: "To bake bread you need flour" },
+  { title: "Bread Recipe", content: "To bake bread you need yeast" },
+];
+const query = "What do you need to bake bread?";
+```
+
+### Step 3: Perform Reranking
+
+Use the `rerank` method to reorder the documents based on the query.
+
+```ts
+const result = await reranker.rerank(documents, query);
+console.log(result); // Perfectly customized results, ready to serve.
+```
+
+## API Reference
+
+- [MixedbreadAIReranker](../../api/classes/MixedbreadAIReranker.md)

apps/docs/docs/modules/query_engines/index.md

@@ -1,6 +1,6 @@
 # QueryEngine
 
-A query engine wraps a `Retriever` and a `ResponseSynthesizer` into a pipeline, that will use the query string to fetech nodes and then send them to the LLM to generate a response.
+A query engine wraps a `Retriever` and a `ResponseSynthesizer` into a pipeline, that will use the query string to fetch nodes and then send them to the LLM to generate a response.
 
 ```typescript
 const queryEngine = index.asQueryEngine();

apps/docs/docs/modules/query_engines/metadata_filtering.md

@@ -75,7 +75,7 @@ const queryEngine = index.asQueryEngine({
       {
         key: "dogId",
         value: "2",
-        filterType: "ExactMatch",
+        operator: "==",
       },
     ],
   },
@@ -88,6 +88,8 @@ const response = await queryEngine.query({
 console.log(response.toString());
 ```
 
+Besides using the equal operator (`==`), you can also use a whole set of different [operators](../../api/interfaces/MetadataFilter.md#operator) to filter your documents.
+
 ## Full Code
 
 ```ts
@@ -135,7 +137,7 @@ async function main() {
           {
             key: "dogId",
             value: "2",
-            filterType: "ExactMatch",
+            operator: "==",
           },
         ],
       },
@@ -156,3 +158,4 @@ main();
 
 - [VectorStoreIndex](../../api/classes/VectorStoreIndex.md)
 - [ChromaVectorStore](../../api/classes/ChromaVectorStore.md)
+- [MetadataFilter](../../api/interfaces/MetadataFilter.md)

apps/docs/docs/modules/query_engines/router_query_engine.md

@@ -15,7 +15,7 @@ import {
   OpenAI,
   RouterQueryEngine,
   SimpleDirectoryReader,
-  SimpleNodeParser,
+  SentenceSplitter,
   SummaryIndex,
   VectorStoreIndex,
   Settings,
@@ -34,11 +34,11 @@ const documents = await new SimpleDirectoryReader().loadData({
 
 ## Service Context
 
-Next, we need to define some basic rules and parse the documents into nodes. We will use the `SimpleNodeParser` to parse the documents into nodes and `Settings` to define the rules (eg. LLM API key, chunk size, etc.):
+Next, we need to define some basic rules and parse the documents into nodes. We will use the `SentenceSplitter` to parse the documents into nodes and `Settings` to define the rules (eg. LLM API key, chunk size, etc.):
 
 ```ts
 Settings.llm = new OpenAI();
-Settings.nodeParser = new SimpleNodeParser({
+Settings.nodeParser = new SentenceSplitter({
   chunkSize: 1024,
 });
 ```
@@ -104,14 +104,14 @@ import {
   OpenAI,
   RouterQueryEngine,
   SimpleDirectoryReader,
-  SimpleNodeParser,
+  SentenceSplitter,
   SummaryIndex,
   VectorStoreIndex,
   Settings,
 } from "llamaindex";
 
 Settings.llm = new OpenAI();
-Settings.nodeParser = new SimpleNodeParser({
+Settings.nodeParser = new SentenceSplitter({
   chunkSize: 1024,
 });
 

apps/docs/docs/modules/retriever.md

@@ -4,18 +4,20 @@ sidebar_position: 5
 
 # Retriever
 
-A retriever in LlamaIndex is what is used to fetch `Node`s from an index using a query string. Aa `VectorIndexRetriever` will fetch the top-k most similar nodes. Meanwhile, a `SummaryIndexRetriever` will fetch all nodes no matter the query.
+A retriever in LlamaIndex is what is used to fetch `Node`s from an index using a query string.
+
+- [VectorIndexRetriever](../api/classes/VectorIndexRetriever.md) will fetch the top-k most similar nodes. Ideal for dense retrieval to find most relevant nodes.
+- [SummaryIndexRetriever](../api/classes/SummaryIndexRetriever.md) will fetch all nodes no matter the query. Ideal when complete context is necessary, e.g. analyzing large datasets.
+- [SummaryIndexLLMRetriever](../api/classes/SummaryIndexLLMRetriever.md) utilizes an LLM to score and filter nodes based on relevancy to the query.
+- [KeywordTableLLMRetriever](../api/classes/KeywordTableLLMRetriever.md) uses an LLM to extract keywords from the query and retrieve relevant nodes based on keyword matches.
+- [KeywordTableSimpleRetriever](../api/classes/KeywordTableSimpleRetriever.md) uses a basic frequency-based approach to extract keywords and retrieve nodes.
+- [KeywordTableRAKERetriever](../api/classes/KeywordTableRAKERetriever.md) uses the RAKE (Rapid Automatic Keyword Extraction) algorithm to extract keywords from the query, focusing on co-occurrence and context for keyword-based retrieval.
 
 ```typescript
-const retriever = vector_index.asRetriever();
-retriever.similarityTopK = 3;
+const retriever = vectorIndex.asRetriever({
+  similarityTopK: 3,
+});
 
 // Fetch nodes!
 const nodesWithScore = await retriever.retrieve({ query: "query string" });
 ```
-
-## API Reference
-
-- [SummaryIndexRetriever](../api/classes/SummaryIndexRetriever.md)
-- [SummaryIndexLLMRetriever](../api/classes/SummaryIndexLLMRetriever.md)
-- [VectorIndexRetriever](../api/classes/VectorIndexRetriever.md)

apps/docs/docusaurus.config.js

@@ -25,30 +25,6 @@ const config = {
   onBrokenLinks: "warn",
   onBrokenMarkdownLinks: "warn",
 
-  // Even if you don't use internalization, you can use this field to set useful
-  // metadata like html lang. For example, if your site is Chinese, you may want
-  // to replace "en" with "zh-Hans".
-  i18n: {
-    defaultLocale: "en",
-    locales: [
-      "en",
-      "zh-Hans",
-      "es",
-      "fr",
-      "de",
-      "ja",
-      "ko",
-      "pt",
-      "ar",
-      "it",
-      "tr",
-      "pl",
-      "nl",
-      "vi",
-      "th",
-    ], // "fa", "ru", "ro", "sv", "hu", "cs", "el", "da", "fi", "he", "no", "hi", "in", "sl", "se", "sk", "uk", "bg", "hr", "lt", "lv", "et", "cat"
-  },
-
   presets: [
     [
       "@docusaurus/preset-classic",

apps/docs/i18n/ar/docusaurus-plugin-content-docs/current/api

@@ -1 +0,0 @@
-../../../../docs/api

apps/docs/i18n/ar/docusaurus-plugin-content-docs/current/concepts.md

@@ -1,86 +0,0 @@
----
-sidebar_position: 3
----
-
-# المفاهيم على المستوى العالي
-
-`تمت ترجمة هذه الوثيقة تلقائيًا وقد تحتوي على أخطاء. لا تتردد في فتح طلب سحب لاقتراح تغييرات.`
-
-يساعدك LlamaIndex.TS في بناء تطبيقات قائمة على LLM (مثل Q&A و chatbot) على بيانات مخصصة.
-
-في هذا الدليل عن المفاهيم على المستوى العالي، ستتعلم:
-
-- كيف يمكن لـ LLM الإجابة على الأسئلة باستخدام بياناتك الخاصة.
-- المفاهيم الرئيسية والوحدات في LlamaIndex.TS لبناء خط أنابيب الاستعلام الخاص بك.
-
-## الإجابة على الأسئلة عبر بياناتك
-
-يستخدم LlamaIndex طريقة مكونة من مرحلتين عند استخدام LLM مع بياناتك:
-
-1. **مرحلة الفهرسة**: إعداد قاعدة المعرفة، و
-2. **مرحلة الاستعلام**: استرداد السياق ذي الصلة من المعرفة لمساعدة LLM في الاستجابة لسؤال
-
-![](./_static/concepts/rag.jpg)
-
-تُعرف هذه العملية أيضًا باسم "استرجاع معزز للتوليد" (RAG).
-
-يوفر LlamaIndex.TS أدوات أساسية لجعل كلا المرحلتين سهلتين للغاية.
-
-دعنا نستكشف كل مرحلة بالتفصيل.
-
-### مرحلة الفهرسة
-
-يساعدك LlamaIndex.TS في إعداد قاعدة المعرفة باستخدام مجموعة من موصلات البيانات والفهارس.
-
-![](./_static/concepts/indexing.jpg)
-
-[**محمّلات البيانات**](./modules/high_level/data_loader.md):
-موصل البيانات (أي `Reader`) يقوم بتجميع البيانات من مصادر بيانات مختلفة وتنسيقات بيانات مختلفة في تمثيل بسيط للـ `Document` (نص وبيانات تعريفية بسيطة).
-
-[**المستندات / العقد**](./modules/high_level/documents_and_nodes.md): المستند هو حاوية عامة حول أي مصدر بيانات - على سبيل المثال، ملف PDF، نتائج واجهة برمجة التطبيقات، أو بيانات استرداد من قاعدة بيانات. العقد هو الوحدة الذرية للبيانات في LlamaIndex ويمثل "قطعة" من المستند الأصلي. إنه تمثيل غني يتضمن بيانات تعريفية وعلاقات (مع عقد أخرى) لتمكين عمليات الاسترجاع الدقيقة والتعبيرية.
-
-[**فهارس البيانات**](./modules/high_level/data_index.md):
-بمجرد أن تقوم بتجميع بياناتك، يساعدك LlamaIndex في فهرسة البيانات في تنسيق سهل الاسترداد.
-
-تحت الغطاء، يقوم LlamaIndex بتحليل المستندات الخام إلى تمثيلات وسيطة، وحساب تضمينات الناقلات، وتخزين بياناتك في الذاكرة أو على القرص.
-
-"
-
-### مرحلة الاستعلام
-
-في مرحلة الاستعلام، يقوم خط الأنابيب للاستعلام بجلب السياق الأكثر صلة بناءً على استعلام المستخدم،
-ويمرر ذلك إلى LLM (جنبًا إلى جنب مع الاستعلام) لتوليد استجابة.
-
-يمنح ذلك LLM معرفة محدثة ليست موجودة في بيانات التدريب الأصلية لديه،
-(مما يقلل أيضًا من الهلوسة).
-
-التحدي الرئيسي في مرحلة الاستعلام هو الاسترجاع والتنسيق والاستدلال عبر قواعد المعرفة (المحتملة).
-
-يوفر LlamaIndex وحدات قابلة للتركيب تساعدك في بناء ودمج خطوط أنابيب RAG لـ Q&A (محرك الاستعلام)، chatbot (محرك الدردشة)، أو كجزء من وكيل.
-
-يمكن تخصيص هذه الكتل البنائية لتعكس تفضيلات التصنيف، وكذلك تركيبها للاستدلال عبر عدة قواعد معرفة بطريقة منظمة.
-
-![](./_static/concepts/querying.jpg)
-
-#### الكتل الأساسية
-
-[**مسترجعات**](./modules/low_level/retriever.md):
-يحدد المسترجع كيفية استرجاع السياق ذي الصلة بكفاءة من قاعدة المعرفة (أي الفهرس) عند إعطاء استعلام.
-تختلف منطق الاسترجاع المحددة حسب الفهارس المختلفة، والأكثر شيوعًا هو الاسترجاع الكثيف ضد فهرس الناقل.
-
-[**مركبات الاستجابة**](./modules/low_level/response_synthesizer.md):
-تقوم مركبة الاستجابة بتوليد استجابة من LLM باستخدام استعلام المستخدم ومجموعة معينة من أجزاء النص المسترجعة.
-
-"
-
-#### خطوط الأنابيب
-
-[**محركات الاستعلام**](./modules/high_level/query_engine.md):
-محرك الاستعلام هو خط أنابيب شامل يتيح لك طرح الأسئلة على بياناتك.
-يأخذ استعلامًا بلغة طبيعية ويعيد استجابة، جنبًا إلى جنب مع السياق المرجعي المسترجع والممرر إلى LLM.
-
-[**محركات الدردشة**](./modules/high_level/chat_engine.md):
-محرك الدردشة هو خط أنابيب شامل لإجراء محادثة مع بياناتك
-(عدة تفاعلات بدلاً من سؤال وجواب واحد).
-
-"

apps/docs/i18n/ar/docusaurus-plugin-content-docs/current/end_to_end.md

@@ -1,61 +0,0 @@
----
-sidebar_position: 4
----
-
-# أمثلة من البداية إلى النهاية
-
-`تمت ترجمة هذه الوثيقة تلقائيًا وقد تحتوي على أخطاء. لا تتردد في فتح طلب سحب لاقتراح تغييرات.`
-
-نقدم العديد من الأمثلة من البداية إلى النهاية باستخدام LlamaIndex.TS في المستودع
-
-تحقق من الأمثلة أدناه أو جربها وأكملها في دقائق مع دروس تفاعلية على Github Codespace المقدمة من Dev-Docs [هنا](https://codespaces.new/team-dev-docs/lits-dev-docs-playground?devcontainer_path=.devcontainer%2Fjavascript_ltsquickstart%2Fdevcontainer.json):
-
-## [محرك الدردشة](https://github.com/run-llama/LlamaIndexTS/blob/main/examples/chatEngine.ts)
-
-اقرأ ملفًا وتحدث عنه مع LLM.
-
-## [فهرس الفيكتور](https://github.com/run-llama/LlamaIndexTS/blob/main/examples/vectorIndex.ts)
-
-إنشاء فهرس فيكتور واستعلامه. سيستخدم فهرس الفيكتور التضمينات لاسترداد أعلى k عقد ذات صلة. بشكل افتراضي ، يكون k الأعلى هو 2.
-
-"
-
-## [مؤشر الملخص](https://github.com/run-llama/LlamaIndexTS/blob/main/examples/summaryIndex.ts)
-
-إنشاء مؤشر قائمة واستعلامه. يستخدم هذا المثال أيضًا `LLMRetriever` ، الذي سيستخدم LLM لتحديد أفضل العقد لاستخدامها عند إنشاء الإجابة.
-
-"
-
-## [حفظ / تحميل فهرس](https://github.com/run-llama/LlamaIndexTS/blob/main/examples/storageContext.ts)
-
-إنشاء وتحميل فهرس ناقل. يحدث التخزين المؤقت على القرص تلقائيًا في LlamaIndex.TS بمجرد إنشاء كائن سياق التخزين.
-
-"
-
-## [فهرس الناقل المخصص](https://github.com/run-llama/LlamaIndexTS/blob/main/examples/vectorIndexCustomize.ts)
-
-إنشاء فهرس ناقل واستعلامه، مع تكوين `LLM` و `ServiceContext` و `similarity_top_k`.
-
-"
-
-## [OpenAI LLM](https://github.com/run-llama/LlamaIndexTS/blob/main/examples/openai.ts)
-
-أنشئ OpenAI LLM واستخدمه مباشرة للدردشة.
-
-"
-
-## [Llama2 DeuceLLM](https://github.com/run-llama/LlamaIndexTS/blob/main/examples/llamadeuce.ts)
-
-إنشاء Llama-2 LLM واستخدامه مباشرة للدردشة.
-
-"
-
-## [محرك استعلام الأسئلة الفرعية](https://github.com/run-llama/LlamaIndexTS/blob/main/examples/subquestion.ts)
-
-يستخدم `محرك استعلام الأسئلة الفرعية` الذي يقسم الاستعلامات المعقدة إلى أسئلة فرعية متعددة، ثم يجمع الاستجابة عبر الإجابات على جميع الأسئلة الفرعية.
-
-"
-
-## [وحدات منخفضة المستوى](https://github.com/run-llama/LlamaIndexTS/blob/main/examples/lowlevel.ts)
-
-يستخدم هذا المثال العديد من المكونات منخفضة المستوى، مما يزيل الحاجة إلى محرك استعلام فعلي. يمكن استخدام هذه المكونات في أي مكان، في أي تطبيق، أو تخصيصها وتصنيفها الفرعي لتلبية احتياجاتك الخاصة.

apps/docs/i18n/ar/docusaurus-plugin-content-docs/current/environments.md

@@ -1,17 +0,0 @@
----
-sidebar_position: 5
----
-
-# البيئات
-
-`تمت ترجمة هذه الوثيقة تلقائيًا وقد تحتوي على أخطاء. لا تتردد في فتح طلب سحب لاقتراح تغييرات.`
-
-يدعم LlamaIndex حاليًا رسميًا NodeJS 18 و NodeJS 20.
-
-## NextJS App Router
-
-إذا كنت تستخدم معالج الطرق / الوظائف الخادمة في NextJS App Router ، فستحتاج إلى استخدام وضع NodeJS:
-
-```js
-export const runtime = "nodejs"; // الافتراضي
-```

apps/docs/i18n/ar/docusaurus-plugin-content-docs/current/installation.mdx

@@ -1,67 +0,0 @@
----
-sidebar_position: 1
----
-
-# التثبيت والإعداد
-
-`تمت ترجمة هذه الوثيقة تلقائيًا وقد تحتوي على أخطاء. لا تتردد في فتح طلب سحب لاقتراح تغييرات.`
-
-تأكد من أن لديك NodeJS v18 أو أحدث.
-
-## باستخدام create-llama
-
-أسهل طريقة للبدء مع LlamaIndex هي باستخدام `create-llama`. هذه الأداة سطر الأوامر تمكنك من بدء بناء تطبيق LlamaIndex جديد بسرعة، مع كل شيء معد لك.
-
-ما عليك سوى تشغيل
-
-<Tabs>
-<TabItem value="1" label="npm" default>
-
-```bash
-npx create-llama@latest
-```
-
-</TabItem>
-<TabItem value="2" label="Yarn">
-
-```bash
-yarn create llama
-```
-
-</TabItem>
-<TabItem value="3" label="pnpm">
-
-```bash
-pnpm create llama@latest
-```
-
-</TabItem>
-</Tabs>
-
-للبدء. بمجرد إنشاء التطبيق الخاص بك، قم بتشغيل
-
-```bash npm2yarn
-npm run dev
-```
-
-لبدء خادم التطوير. يمكنك ثم زيارة [http://localhost:3000](http://localhost:3000) لرؤية تطبيقك.
-
-## التثبيت من NPM
-
-```bash npm2yarn
-npm install llamaindex
-```
-
-### المتغيرات البيئية
-
-تستخدم أمثلتنا OpenAI افتراضيًا. ستحتاج إلى إعداد مفتاح Open AI الخاص بك على النحو التالي:
-
-```bash
-export OPENAI_API_KEY="sk-......" # استبدله بالمفتاح الخاص بك من https://platform.openai.com/account/api-keys
-```
-
-إذا كنت ترغب في تحميله تلقائيًا في كل مرة، قم بإضافته إلى ملف .zshrc/.bashrc الخاص بك.
-
-تحذير: لا تقم بإضافة مفتاح OpenAI الخاص بك إلى نظام التحكم في الإصدارات.
-
-"

apps/docs/i18n/ar/docusaurus-plugin-content-docs/current/introduction.md

@@ -1,60 +0,0 @@
----
-sidebar_position: 0
-slug: /
----
-
-# ما هو LlamaIndex.TS؟
-
-`تمت ترجمة هذه الوثيقة تلقائيًا وقد تحتوي على أخطاء. لا تتردد في فتح طلب سحب لاقتراح تغييرات.`
-
-LlamaIndex.TS هو إطار بيانات لتطبيقات LLM لاستيعاب وتنظيم والوصول إلى البيانات الخاصة أو الخاصة بالمجال. في حين أن حزمة Python متاحة أيضًا (انظر [هنا](https://docs.llamaindex.ai/en/stable/)), يوفر LlamaIndex.TS ميزات أساسية في حزمة بسيطة ، محسنة للاستخدام مع TypeScript.
-
-## 🚀 لماذا LlamaIndex.TS؟
-
-في جوهرها ، توفر LLMs واجهة لغة طبيعية بين البشر والبيانات المستنتجة. تأتي النماذج المتاحة على نطاق واسع محملة مسبقًا بكميات هائلة من البيانات المتاحة للجمهور ، من ويكيبيديا وقوائم البريد الإلكتروني إلى الكتب المدرسية وشفرة المصدر.
-
-غالبًا ما تتطلب التطبيقات المبنية على LLMs تعزيز هذه النماذج بالبيانات الخاصة أو الخاصة بالمجال. للأسف ، يمكن توزيع هذه البيانات عبر تطبيقات ومخازن بيانات معزولة. إنها خلف واجهات برمجة التطبيقات ، في قواعد البيانات SQL ، أو محبوسة في ملفات PDF وعروض تقديمية.
-
-هنا يأتي دور **LlamaIndex.TS**.
-
-## 🦙 كيف يمكن أن يساعد LlamaIndex.TS؟
-
-يوفر LlamaIndex.TS الأدوات التالية:
-
-- **تحميل البيانات**: استيعاب البيانات الحالية الخاصة بك بتنسيقات `.txt`, `.pdf`, `.csv`, `.md` و `.docx` مباشرة.
-- **فهارس البيانات**: تنظيم البيانات الخاصة بك في تمثيلات وسيطة سهلة وفعالة للاستخدام من قبل LLMs.
-- **المحركات**: توفر واجهات الوصول إلى اللغة الطبيعية لبياناتك. على سبيل المثال:
-  - محركات الاستعلام هي واجهات استرجاع قوية للإخراج المعزز بالمعرفة.
-  - محركات الدردشة هي واجهات محادثة للتفاعلات "ذهابًا وإيابًا" متعددة الرسائل مع بياناتك.
-
-## 👨‍👩‍👧‍👦 من أجل من هو LlamaIndex؟
-
-يوفر LlamaIndex.TS مجموعة أدوات أساسية ، ضرورية لأي شخص يقوم ببناء تطبيقات LLM باستخدام JavaScript و TypeScript.
-
-يتيح لنا واجهة برمجة التطبيقات على مستوى عالي استخدام LlamaIndex.TS لاستيعاب واستعلام البيانات الخاصة بهم.
-
-بالنسبة للتطبيقات المعقدة أكثر ، تتيح لنا واجهات برمجة التطبيقات على مستوى أدنى للمستخدمين المتقدمين تخصيص وتوسيع أي وحدة - موصلات البيانات والفهارس وأجهزة الاسترجاع ومحركات الاستعلام - لتناسب احتياجاتهم.
-
-## البدء
-
-`npm install llamaindex`
-
-تتضمن وثائقنا [تعليمات التثبيت](./installation.mdx) و[دليل البداية](./starter.md) لبناء تطبيقك الأول.
-
-بمجرد أن تكون جاهزًا وتعمل ، يحتوي [مفاهيم عالية المستوى](./getting_started/concepts.md) على نظرة عامة على الهندسة المعمارية المتعددة المستويات لـ LlamaIndex. لمزيد من الأمثلة العملية التفصيلية ، يمكنك الاطلاع على [دروس النهاية إلى النهاية](./end_to_end.md).
-
-## 🗺️ النظام البيئي
-
-لتنزيل أو المساهمة ، ابحث عن LlamaIndex على:
-
-- Github: https://github.com/run-llama/LlamaIndexTS
-- NPM: https://www.npmjs.com/package/llamaindex
-
-"
-
-## المجتمع
-
-هل تحتاج إلى مساعدة؟ هل لديك اقتراح لميزة؟ انضم إلى مجتمع LlamaIndex:
-
-- تويتر: https://twitter.com/llama_index
-- ديسكورد: https://discord.gg/dGcwcsnxhU

apps/docs/i18n/ar/docusaurus-plugin-content-docs/current/modules/high_level/chat_engine.md

@@ -1,22 +0,0 @@
----
-sidebar_position: 4
----
-
-# محرك الدردشة (ChatEngine)
-
-`تمت ترجمة هذه الوثيقة تلقائيًا وقد تحتوي على أخطاء. لا تتردد في فتح طلب سحب لاقتراح تغييرات.`
-
-محرك الدردشة هو طريقة سريعة وبسيطة للدردشة مع البيانات في الفهرس الخاص بك.
-
-```typescript
-const retriever = index.asRetriever();
-const chatEngine = new ContextChatEngine({ retriever });
-
-// بدء الدردشة
-const response = await chatEngine.chat(query);
-```
-
-## مراجع الواجهة البرمجية
-
-- [محرك الدردشة السياقي (ContextChatEngine)](../../api/classes/ContextChatEngine.md)
-- [محرك الدردشة المكثف للأسئلة (CondenseQuestionChatEngine)](../../api/classes/ContextChatEngine.md)

apps/docs/i18n/ar/docusaurus-plugin-content-docs/current/modules/high_level/data_index.md

@@ -1,27 +0,0 @@
----
-sidebar_position: 2
----
-
-# الفهرس
-
-`تمت ترجمة هذه الوثيقة تلقائيًا وقد تحتوي على أخطاء. لا تتردد في فتح طلب سحب لاقتراح تغييرات.`
-
-الفهرس هو الحاوية الأساسية والتنظيم لبياناتك. يدعم LlamaIndex.TS نوعين من الفهارس:
-
-- `VectorStoreIndex` - سيقوم بإرسال أعلى `Node` الموجودة إلى LLM عند إنشاء استجابة. القيمة الافتراضية لأعلى `k` هي 2.
-- `SummaryIndex` - سيقوم بإرسال كل `Node` في الفهرس إلى LLM لإنشاء استجابة.
-
-```typescript
-import { Document, VectorStoreIndex } from "llamaindex";
-
-const document = new Document({ text: "اختبار" });
-
-const index = await VectorStoreIndex.fromDocuments([document]);
-```
-
-## مرجع الواجهة البرمجية
-
-- [SummaryIndex](../../api/classes/SummaryIndex.md)
-- [VectorStoreIndex](../../api/classes/VectorStoreIndex.md)
-
-"

apps/docs/i18n/ar/docusaurus-plugin-content-docs/current/modules/high_level/data_loader.md

@@ -1,19 +0,0 @@
----
-sidebar_position: 1
----
-
-# قارئ / محمل
-
-`تمت ترجمة هذه الوثيقة تلقائيًا وقد تحتوي على أخطاء. لا تتردد في فتح طلب سحب لاقتراح تغييرات.`
-
-يدعم LlamaIndex.TS تحميل الملفات بسهولة من المجلدات باستخدام فئة `SimpleDirectoryReader`. حاليًا ، يتم دعم الملفات `.txt` ، `.pdf` ، `.csv` ، `.md` و `.docx` ، مع المزيد المخطط له في المستقبل!
-
-```typescript
-import { SimpleDirectoryReader } from "llamaindex";
-
-documents = new SimpleDirectoryReader().loadData("./data");
-```
-
-## مرجع الواجهة البرمجية
-
-- [SimpleDirectoryReader](../../api/classes/SimpleDirectoryReader.md)

apps/docs/i18n/ar/docusaurus-plugin-content-docs/current/modules/high_level/documents_and_nodes.md

@@ -1,22 +0,0 @@
----
-sidebar_position: 0
----
-
-# المستندات والعقد
-
-`تمت ترجمة هذه الوثيقة تلقائيًا وقد تحتوي على أخطاء. لا تتردد في فتح طلب سحب لاقتراح تغييرات.`
-
-`المستندات` و `العقد` هما العناصر الأساسية لأي فهرس. بينما يكون واجهة برمجة التطبيق (API) لهذه الكائنات مشابهة، يُمثل كائن `المستند` ملفات كاملة، بينما تكون `العقد` قطعًا أصغر من ذلك المستند الأصلي، والتي تكون مناسبة لـ LLM و Q&A.
-
-```typescript
-import { Document } from "llamaindex";
-
-document = new Document({ text: "نص", metadata: { key: "val" } });
-```
-
-## مرجع الواجهة البرمجية
-
-- [المستند (Document)](../../api/classes/Document.md)
-- [نص العقد (TextNode)](../../api/classes/TextNode.md)
-
-"

apps/docs/i18n/ar/docusaurus-plugin-content-docs/current/modules/high_level/query_engine.md

@@ -1,42 +0,0 @@
----
-sidebar_position: 3
----
-
-# محرك الاستعلامات (QueryEngine)
-
-`تمت ترجمة هذه الوثيقة تلقائيًا وقد تحتوي على أخطاء. لا تتردد في فتح طلب سحب لاقتراح تغييرات.`
-
-يقوم محرك الاستعلامات بتجميع "Retriever" و "ResponseSynthesizer" في أنبوبة، والتي ستستخدم سلسلة الاستعلام لاسترداد العقد ومن ثم إرسالها إلى LLM لتوليد استجابة.
-
-```typescript
-const queryEngine = index.asQueryEngine();
-const response = await queryEngine.query("سلسلة الاستعلام");
-```
-
-## محرك الاستعلام للأسئلة الفرعية
-
-الفكرة الأساسية لمحرك الاستعلام للأسئلة الفرعية هي تقسيم استعلام واحد إلى استعلامات متعددة، والحصول على إجابة لكل من تلك الاستعلامات، ثم دمج تلك الإجابات المختلفة في استجابة واحدة متسقة للمستخدم. يمكنك أن تفكر فيها كتقنية "فكر في ذلك خطوة بخطوة" ولكن بتكرار مصادر البيانات الخاصة بك!
-
-### البدء
-
-أسهل طريقة لبدء تجربة محرك الاستعلام للأسئلة الفرعية هي تشغيل ملف subquestion.ts في [examples](https://github.com/run-llama/LlamaIndexTS/blob/main/examples/subquestion.ts).
-
-```bash
-npx ts-node subquestion.ts
-```
-
-"
-
-### الأدوات
-
-يتم تنفيذ محرك الاستعلام للأسئلة الفرعية باستخدام الأدوات. الفكرة الأساسية للأدوات هي أنها خيارات قابلة للتنفيذ لنموذج اللغة الكبيرة. في هذه الحالة، يعتمد محرك الاستعلام للأسئلة الفرعية على أداة QueryEngineTool، والتي كما تخمن هي أداة لتشغيل استعلامات على محرك الاستعلام. يتيح لنا ذلك إعطاء النموذج خيارًا للاستعلام عن وثائق مختلفة لأسئلة مختلفة على سبيل المثال. يمكنك أيضًا أن تتخيل أن محرك الاستعلام للأسئلة الفرعية يمكنه استخدام أداة تبحث عن شيء ما على الويب أو تحصل على إجابة باستخدام Wolfram Alpha.
-
-يمكنك معرفة المزيد عن الأدوات من خلال الاطلاع على وثائق LlamaIndex Python https://gpt-index.readthedocs.io/en/latest/core_modules/agent_modules/tools/root.html
-
-"
-
-## مرجع واجهة برمجة التطبيق (API)
-
-- [محرك استعلام الاسترجاع (RetrieverQueryEngine)](../../api/classes/RetrieverQueryEngine.md)
-- [محرك استعلام السؤال الفرعي (SubQuestionQueryEngine)](../../api/classes/SubQuestionQueryEngine.md)
-- [أداة محرك الاستعلام (QueryEngineTool)](../../api/interfaces/QueryEngineTool.md)

apps/docs/i18n/ar/docusaurus-plugin-content-docs/current/modules/index.md

@@ -1,33 +0,0 @@
-# الوحدات الأساسية
-
-`تمت ترجمة هذه الوثيقة تلقائيًا وقد تحتوي على أخطاء. لا تتردد في فتح طلب سحب لاقتراح تغييرات.`
-
-يوفر LlamaIndex.TS عدة وحدات أساسية، مقسمة إلى وحدات عالية المستوى للبدء السريع ووحدات منخفضة المستوى لتخصيص المكونات الرئيسية حسب الحاجة.
-
-## وحدات عالية المستوى
-
-- [**المستند**](./high_level/documents_and_nodes.md): يمثل المستند ملف نصي أو ملف PDF أو قطعة بيانات متتابعة أخرى.
-
-- [**العقدة**](./high_level/documents_and_nodes.md): هو البناء الأساسي للبيانات. في أغلب الأحيان، تكون هذه أجزاء من المستند المقسمة إلى قطع قابلة للإدارة وصغيرة بما يكفي ليتم تغذيتها إلى نموذج التضمين و LLM.
-
-- [**القارئ/المحمل**](./high_level/data_loader.md): القارئ أو المحمل هو شيء يأخذ المستند في العالم الحقيقي ويحوله إلى فئة المستند التي يمكن استخدامها في الفهرس الخاص بك والاستعلامات. ندعم حاليًا ملفات النص العادي وملفات PDF والمزيد الكثير.
-
-- [**الفهارس**](./high_level/data_index.md): تخزن الفهارس العقد وتضمينات تلك العقد.
-
-- [**محرك الاستعلامات**](./high_level/query_engine.md): محركات الاستعلامات هي التي تولد الاستعلام الذي تدخله وتعيد لك النتيجة. عمومًا، تجمع محركات الاستعلامات بين تعليمة مسبقة مبنية مع العقد المحددة من الفهرس الخاص بك لتعطي LLM السياق الذي يحتاجه للإجابة على استعلامك.
-
-- [**محرك الدردشة**](./high_level/chat_engine.md): يساعدك محرك الدردشة على بناء روبوت دردشة سيتفاعل مع فهرسك.
-
-## وحدة منخفضة المستوى
-
-- [**LLM**](./low_level/llm.md): فئة LLM هي واجهة موحدة فوق مزود نموذج لغة كبير مثل OpenAI GPT-4 أو Anthropic Claude أو Meta LLaMA. يمكنك توريثها لكتابة موصل إلى نموذج اللغة الخاص بك.
-
-- [**Embedding**](./low_level/embedding.md): يتم تمثيل التضمين كمتجه من الأرقام العائمة. نموذج التضمين الافتراضي لدينا هو text-embedding-ada-002 من OpenAI ويتكون كل تضمين يولده من 1,536 رقمًا عائمًا. نموذج التضمين الشائع الآخر هو BERT الذي يستخدم 768 رقمًا عائمًا لتمثيل كل عقدة. نوفر عددًا من الأدوات للعمل مع التضمين بما في ذلك 3 خيارات لحساب التشابه و Maximum Marginal Relevance.
-
-- [**TextSplitter/NodeParser**](./low_level/node_parser.md): تعتبر استراتيجيات تقسيم النصوص مهمة للغاية لفعالية البحث في التضمين. حاليًا، على الرغم من أن لدينا قيمة افتراضية، إلا أنه لا يوجد حلاً مناسبًا للجميع. اعتمادًا على وثائق المصدر، قد ترغب في استخدام أحجام واستراتيجيات تقسيم مختلفة. حاليًا، ندعم التقسيم حسب الحجم الثابت، التقسيم حسب الحجم الثابت مع أجزاء تتداخل، التقسيم حسب الجملة، والتقسيم حسب الفقرة. يتم استخدام مقسم النصوص بواسطة NodeParser عند تقسيم `Document` إلى `Node`.
-
-- [**Retriever**](./low_level/retriever.md): يقوم Retriever بتحديد العقد التي يتم استردادها من الفهرس. هنا، قد ترغب في محاولة استرداد عدد أكبر أو أقل من العقد لكل استعلام، تغيير وظيفة التشابه الخاصة بك، أو إنشاء استرداد خاص بك لكل حالة استخدام فردية في تطبيقك. على سبيل المثال، قد ترغب في وجود استرداد منفصل لمحتوى الشفرة مقابل محتوى النص.
-
-- [**ResponseSynthesizer**](./low_level/response_synthesizer.md): يتحمل ResponseSynthesizer مسؤولية أخذ سلسلة استعلام واستخدام قائمة من العقد لإنشاء استجابة. يمكن أن يأخذ هذا الشكل العديد من الأشكال، مثل التكرار عبر جميع السياق وتحسين الإجابة، أو بناء شجرة من الملخصات وإرجاع الملخص الجذري.
-
-- [**Storage**](./low_level/storage.md): في نقطة ما، سترغب في تخزين الفهارس والبيانات والمتجهات بدلاً من إعادة تشغيل نماذج التضمين في كل مرة. IndexStore و DocStore و VectorStore و KVStore هي تجريدات تتيح لك ذلك. مجتمعة، تشكل هذه التجريدات سياق التخزين. حاليًا، نسمح لك بالاحتفاظ بالتضمينات الخاصة بك في ملفات على نظام الملفات (أو نظام ملفات افتراضي في الذاكرة)، ولكننا نضيف أيضًا تكاملات مع قواعد بيانات المتجهات.

apps/docs/i18n/ar/docusaurus-plugin-content-docs/current/modules/low_level/embedding.md

@@ -1,26 +0,0 @@
----
-sidebar_position: 1
----
-
-# تضمين
-
-`تمت ترجمة هذه الوثيقة تلقائيًا وقد تحتوي على أخطاء. لا تتردد في فتح طلب سحب لاقتراح تغييرات.`
-
-يتولى النموذج المضمن في LlamaIndex إنشاء تمثيلات رقمية للنص. بشكل افتراضي ، ستستخدم LlamaIndex نموذج `text-embedding-ada-002` من OpenAI.
-
-يمكن تعيين ذلك بشكل صريح في كائن `ServiceContext`.
-
-```typescript
-import { OpenAIEmbedding, serviceContextFromDefaults } from "llamaindex";
-
-const openaiEmbeds = new OpenAIEmbedding();
-
-const serviceContext = serviceContextFromDefaults({ embedModel: openaiEmbeds });
-```
-
-## مرجع الواجهة البرمجية
-
-- [OpenAIEmbedding](../../api/classes/OpenAIEmbedding.md)
-- [ServiceContext](../../api/interfaces/ServiceContext.md)
-
-"

apps/docs/i18n/ar/docusaurus-plugin-content-docs/current/modules/low_level/llm.md

@@ -1,26 +0,0 @@
----
-sidebar_position: 0
----
-
-# LLM
-
-`تمت ترجمة هذه الوثيقة تلقائيًا وقد تحتوي على أخطاء. لا تتردد في فتح طلب سحب لاقتراح تغييرات.`
-
-يتولى LLM قراءة النص وتوليد استجابات لغوية طبيعية للاستفسارات. بشكل افتراضي ، يستخدم LlamaIndex.TS `gpt-3.5-turbo`.
-
-يمكن تعيين LLM بشكل صريح في كائن `ServiceContext`.
-
-```typescript
-import { OpenAI, serviceContextFromDefaults } from "llamaindex";
-
-const openaiLLM = new OpenAI({ model: "gpt-3.5-turbo", temperature: 0 });
-
-const serviceContext = serviceContextFromDefaults({ llm: openaiLLM });
-```
-
-## مرجع الواجهة البرمجية
-
-- [OpenAI](../../api/classes/OpenAI.md)
-- [ServiceContext](../../api/interfaces/ServiceContext.md)
-
-"

apps/docs/i18n/ar/docusaurus-plugin-content-docs/current/modules/low_level/node_parser.md

@@ -1,37 +0,0 @@
----
-sidebar_position: 3
----
-
-# NodeParser (محلل العقدة)
-
-`تمت ترجمة هذه الوثيقة تلقائيًا وقد تحتوي على أخطاء. لا تتردد في فتح طلب سحب لاقتراح تغييرات.`
-
-`NodeParser` في LlamaIndex مسؤول عن تقسيم كائنات `Document` إلى كائنات `Node` أكثر إدارة. عند استدعاء `.fromDocuments()`, يتم استخدام `NodeParser` من `ServiceContext` للقيام بذلك تلقائيًا بالنسبة لك. بدلاً من ذلك ، يمكنك استخدامه لتقسيم المستندات مسبقًا.
-
-```typescript
-import { Document, SimpleNodeParser } from "llamaindex";
-
-const nodeParser = new SimpleNodeParser();
-const nodes = nodeParser.getNodesFromDocuments([
-  new Document({ text: "أنا عمري 10 سنوات. جون عمره 20 سنة." }),
-]);
-```
-
-## TextSplitter (مقسم النص)
-
-سيقوم مقسم النص الأساسي بتقسيم النص إلى جمل. يمكن أيضًا استخدامه كوحدة مستقلة لتقسيم النص الخام.
-
-```typescript
-import { SentenceSplitter } from "llamaindex";
-
-const splitter = new SentenceSplitter({ chunkSize: 1 });
-
-const textSplits = splitter.splitText("مرحبًا بالعالم");
-```
-
-## مرجع الواجهة البرمجية
-
-- [SimpleNodeParser (محلل العقدة البسيط)](../../api/classes/SimpleNodeParser.md)
-- [SentenceSplitter (مقسم الجمل)](../../api/classes/SentenceSplitter.md)
-
-"

apps/docs/i18n/ar/docusaurus-plugin-content-docs/current/modules/low_level/response_synthesizer.md

@@ -1,45 +0,0 @@
----
-sidebar_position: 6
----
-
-# مركب الاستجابة (ResponseSynthesizer)
-
-`تمت ترجمة هذه الوثيقة تلقائيًا وقد تحتوي على أخطاء. لا تتردد في فتح طلب سحب لاقتراح تغييرات.`
-
-مركب الاستجابة (ResponseSynthesizer) مسؤول عن إرسال الاستعلام والعقد وقوالب الاستفسار إلى LLM لتوليد استجابة. هناك بعض وسائط رئيسية لتوليد استجابة:
-
-- `تحسين`: "إنشاء وتحسين" إجابة عن طريق المرور تتاليًا عبر كل قطعة نص مُسترجعة. يتم إجراء استدعاء LLM منفصل لكل عقدة. جيد للإجابات المفصلة.
-- `مضغوط وتحسين` (الافتراضي): "ضغط" الاستفسار أثناء كل استدعاء LLM عن طريق حشو أكبر عدد ممكن من قطع النص التي يمكن أن تتناسب مع حجم الاستفسار الأقصى. إذا كان هناك الكثير من القطع لتعبئتها في استفسار واحد، "إنشاء وتحسين" إجابة عن طريق المرور بعدة استفسارات مضغوطة. نفس العملية كـ `تحسين`، ولكن يجب أن تؤدي إلى مزيد من استدعاءات LLM أقل.
-- `ملخص الشجرة`: بناء شجرة بشكل متكرر بناءً على مجموعة من قطع النص والاستعلام، وإرجاع العقدة الجذرية كاستجابة. جيد لأغراض التلخيص.
-- `منشئ الاستجابة البسيط`: تطبيق الاستعلام على كل قطعة نص وتجميع الاستجابات في مصفوفة. يعيد سلسلة متصلة من جميع الاستجابات. جيد عندما تحتاج إلى تشغيل نفس الاستعلام بشكل منفصل على كل قطعة نص.
-
-```typescript
-import { NodeWithScore, ResponseSynthesizer, TextNode } from "llamaindex";
-
-const responseSynthesizer = new ResponseSynthesizer();
-
-const nodesWithScore: NodeWithScore[] = [
-  {
-    node: new TextNode({ text: "أنا عمري 10 سنوات." }),
-    score: 1,
-  },
-  {
-    node: new TextNode({ text: "جون عمره 20 سنة." }),
-    score: 0.5,
-  },
-];
-
-const response = await responseSynthesizer.synthesize(
-  "ما هو عمري؟",
-  nodesWithScore,
-);
-console.log(response.response);
-```
-
-## مرجع الواجهة البرمجية
-
-- [مركب الاستجابة (ResponseSynthesizer)](../../api/classes/ResponseSynthesizer.md)
-- [تحسين (Refine)](../../api/classes/Refine.md)
-- [مضغوط وتحسين (CompactAndRefine)](../../api/classes/CompactAndRefine.md)
-- [ملخص الشجرة (TreeSummarize)](../../api/classes/TreeSummarize.md)
-- [منشئ الاستجابة البسيط (SimpleResponseBuilder)](../../api/classes/SimpleResponseBuilder.md)

apps/docs/i18n/ar/docusaurus-plugin-content-docs/current/modules/low_level/retriever.md

@@ -1,23 +0,0 @@
----
-sidebar_position: 5
----
-
-# الباحث (Retriever)
-
-`تمت ترجمة هذه الوثيقة تلقائيًا وقد تحتوي على أخطاء. لا تتردد في فتح طلب سحب لاقتراح تغييرات.`
-
-الباحث في LlamaIndex هو ما يُستخدم لاسترداد العقد (`Node`) من فهرس باستخدام سلسلة الاستعلام. سيقوم الباحث `VectorIndexRetriever` بجلب أعلى k عقد مشابهة. بينما سيقوم الباحث `SummaryIndexRetriever` بجلب جميع العقد بغض النظر عن الاستعلام.
-
-```typescript
-const retriever = vector_index.asRetriever();
-retriever.similarityTopK = 3;
-
-// جلب العقد!
-const nodesWithScore = await retriever.retrieve({ query: "سلسلة الاستعلام" });
-```
-
-## مرجع الواجهة البرمجية (API Reference)
-
-- [SummaryIndexRetriever](../../api/classes/SummaryIndexRetriever.md)
-- [SummaryIndexLLMRetriever](../../api/classes/SummaryIndexLLMRetriever.md)
-- [VectorIndexRetriever](../../api/classes/VectorIndexRetriever.md)

apps/docs/i18n/ar/docusaurus-plugin-content-docs/current/modules/low_level/storage.md

@@ -1,30 +0,0 @@
----
-sidebar_position: 7
----
-
-# التخزين
-
-`تمت ترجمة هذه الوثيقة تلقائيًا وقد تحتوي على أخطاء. لا تتردد في فتح طلب سحب لاقتراح تغييرات.`
-
-يعمل التخزين في LlamaIndex.TS تلقائيًا بمجرد تكوين كائن `StorageContext`. قم بتكوين `persistDir` وربطه بفهرس.
-
-في الوقت الحالي ، يتم دعم حفظ وتحميل البيانات من القرص فقط ، مع وجود تكاملات مستقبلية مخططة!
-
-```typescript
-import { Document, VectorStoreIndex, storageContextFromDefaults } from "./src";
-
-const storageContext = await storageContextFromDefaults({
-  persistDir: "./storage",
-});
-
-const document = new Document({ text: "نص اختبار" });
-const index = await VectorStoreIndex.fromDocuments([document], {
-  storageContext,
-});
-```
-
-## مرجع الواجهة البرمجية
-
-- [StorageContext](../../api/interfaces/StorageContext.md)
-
-"

apps/docs/i18n/ar/docusaurus-plugin-content-docs/current/starter.md

@@ -1,58 +0,0 @@
----
-sidebar_position: 2
----
-
-# دليل البداية
-
-`تمت ترجمة هذه الوثيقة تلقائيًا وقد تحتوي على أخطاء. لا تتردد في فتح طلب سحب لاقتراح تغييرات.`
-
-بمجرد [تثبيت LlamaIndex.TS باستخدام NPM](installation) وإعداد مفتاح OpenAI الخاص بك، أنت الآن جاهز لبدء تطبيقك الأول:
-
-في مجلد جديد:
-
-```bash npm2yarn
-npm install typescript
-npm install @types/node
-npx tsc --init # إذا لزم الأمر
-```
-
-أنشئ ملف `example.ts`. سيقوم هذا الكود بتحميل بعض البيانات المثالية، وإنشاء وثيقة، وفهرسة الوثيقة (مما ينشئ تضمينات باستخدام OpenAI)، ثم إنشاء محرك الاستعلام للإجابة على الأسئلة حول البيانات.
-
-```ts
-// example.ts
-import fs from "fs/promises";
-import { Document, VectorStoreIndex } from "llamaindex";
-
-async function main() {
-  // تحميل المقالة من abramov.txt في Node
-  const essay = await fs.readFile(
-    "node_modules/llamaindex/examples/abramov.txt",
-    "utf-8",
-  );
-
-  // إنشاء كائن Document بواسطة المقالة
-  const document = new Document({ text: essay });
-
-  // تقسيم النص وإنشاء التضمينات. تخزينها في VectorStoreIndex
-  const index = await VectorStoreIndex.fromDocuments([document]);
-
-  // استعلام الفهرس
-  const queryEngine = index.asQueryEngine();
-  const response = await queryEngine.query("ماذا فعل الكاتب في الكلية؟");
-
-  // إخراج الاستجابة
-  console.log(response.toString());
-}
-
-main();
-```
-
-ثم يمكنك تشغيله باستخدام
-
-```bash
-npx ts-node example.ts
-```
-
-هل أنت مستعد للمزيد من التعلم؟ تفضل بزيارة منصة NextJS الخاصة بنا على https://llama-playground.vercel.app/. يمكنك العثور على المصدر على https://github.com/run-llama/ts-playground
-
-"

apps/docs/i18n/bg/docusaurus-plugin-content-docs/current/api

@@ -1 +0,0 @@
-../../../../docs/api

apps/docs/i18n/bg/docusaurus-plugin-content-docs/current/concepts.md

@@ -1,86 +0,0 @@
----
-sidebar_position: 3
----
-
-# Високо ниво на концепции
-
-`Тази документация е преведена автоматично и може да съдържа грешки. Не се колебайте да отворите Pull Request, за да предложите промени.`
-
-LlamaIndex.TS ви помага да създавате приложения, базирани на LLM (например Q&A, чатбот) върху персонализирани данни.
-
-В това ръководство за високо ниво на концепции ще научите:
-
-- как LLM може да отговори на въпроси, използвайки вашите собствени данни.
-- ключови концепции и модули в LlamaIndex.TS за създаване на ваша собствена заявка.
-
-## Отговаряне на въпроси върху вашите данни
-
-LlamaIndex използва двустепенен метод при използване на LLM с вашите данни:
-
-1. **стъпка за индексиране**: подготовка на база от знания и
-2. **стъпка за заявка**: извличане на съответния контекст от знанията, за да помогне на LLM да отговори на въпрос
-
-![](./_static/concepts/rag.jpg)
-
-Този процес е известен също като Retrieval Augmented Generation (RAG).
-
-LlamaIndex.TS предоставя основния инструментариум, който прави и двете стъпки изключително лесни.
-
-Нека изследваме всяка стъпка подробно.
-
-### Стъпка на индексиране
-
-LlamaIndex.TS ви помага да подготвите базата от знания с помощта на набор от конектори за данни и индекси.
-
-![](./_static/concepts/indexing.jpg)
-
-[**Data Loaders**](./modules/high_level/data_loader.md):
-Конектор за данни (т.е. `Reader`) поема данни от различни източници на данни и формати на данни и ги превръща в просто представяне на `Document` (текст и прости метаданни).
-
-[**Documents / Nodes**](./modules/high_level/documents_and_nodes.md): `Document` е общ контейнер за всякакъв вид данни - например PDF, изход от API или извлечени данни от база данни. `Node` е атомарната единица от данни в LlamaIndex и представлява "част" от източниковия `Document`. Това е богато представяне, което включва метаданни и връзки (към други възли), за да позволи точни и изразителни операции за извличане.
-
-[**Data Indexes**](./modules/high_level/data_index.md):
-След като сте поели данните си, LlamaIndex ви помага да индексирате данните във формат, който е лесен за извличане.
-
-Под капака, LlamaIndex анализира суровите документи в промеждинни представяния, изчислява векторни вложения и съхранява данните в паметта или на диска.
-
-"
-
-### Стъпка за заявка
-
-В стъпката за заявка, конвейерът за заявки извлича най-съответния контекст, даден на потребителска заявка,
-и го предава на LLM (заедно със заявката), за да синтезира отговор.
-
-Това дава на LLM актуални познания, които не са в неговите оригинални обучаващи данни,
-(също така намалява халюцинацията).
-
-Основното предизвикателство в стъпката за заявка е извличането, организирането и резонирането върху (потенциално много) бази от знания.
-
-LlamaIndex предоставя модули, които могат да се комбинират и помагат за създаването и интегрирането на RAG конвейери за Q&A (заявки), чатбот (чат двигател) или като част от агент.
-
-Тези строителни блокове могат да бъдат персонализирани, за да отразяват предпочитанията за ранжиране, както и да бъдат комбинирани, за да резонират върху множество бази от знания по структуриран начин.
-
-![](./_static/concepts/querying.jpg)
-
-#### Строителни блокове
-
-[**Извличатели**](./modules/low_level/retriever.md):
-Извличател дефинира как да се извлича ефективно съответния контекст от база от знания (т.е. индекс), когато се предостави заявка.
-Конкретната логика за извличане се различава за различни индекси, като най-популярното е плътно извличане срещу векторен индекс.
-
-[**Синтезатори на отговори**](./modules/low_level/response_synthesizer.md):
-Синтезаторът на отговор генерира отговор от LLM, използвайки потребителска заявка и даден набор от извлечени текстови части.
-
-"
-
-#### Конвейери
-
-[**Заявки**](./modules/high_level/query_engine.md):
-Заявката е цялостен конвейер, който ви позволява да задавате въпроси относно вашите данни.
-Тя приема заявка на естествен език и връща отговор, заедно с извлечения контекст, предаден на LLM.
-
-[**Чат двигатели**](./modules/high_level/chat_engine.md):
-Чат двигателът е цялостен конвейер за провеждане на разговор с вашите данни
-(множество въпроси и отговори вместо единичен въпрос и отговор).
-
-"

apps/docs/i18n/bg/docusaurus-plugin-content-docs/current/end_to_end.md

@@ -1,57 +0,0 @@
----
-sidebar_position: 4
----
-
-# Примери от начало до край
-
-`Тази документация е преведена автоматично и може да съдържа грешки. Не се колебайте да отворите Pull Request, за да предложите промени.`
-
-Включени са няколко примера от начало до край, използвайки LlamaIndex.TS в хранилището
-
-Разгледайте примерите по-долу или ги опитайте и завършете за минути с интерактивни уроци на Github Codespace, предоставени от Dev-Docs [тук](https://codespaces.new/team-dev-docs/lits-dev-docs-playground?devcontainer_path=.devcontainer%2Fjavascript_ltsquickstart%2Fdevcontainer.json):
-
-## [Чат двигател (Chat Engine)](https://github.com/run-llama/LlamaIndexTS/blob/main/examples/chatEngine.ts)
-
-Прочетете файл и обсъждайте го с LLM.
-
-## [Векторен индекс](https://github.com/run-llama/LlamaIndexTS/blob/main/examples/vectorIndex.ts)
-
-Създайте векторен индекс и го запитайте. Векторният индекс ще използва вграждания, за да извлече най-релевантните k върха. По подразбиране, k е 2.
-
-"
-
-## [Summary Index](https://github.com/run-llama/LlamaIndexTS/blob/main/examples/summaryIndex.ts)
-
-Създайте списъчен индекс и го заявете. Този пример също използва `LLMRetriever`, който използва LLM, за да избере най-добрите възли за използване при генериране на отговор.
-
-"
-
-## [Запазване / Зареждане на индекс](https://github.com/run-llama/LlamaIndexTS/blob/main/examples/storageContext.ts)
-
-Създайте и заредете векторен индекс. Запазването на диска в LlamaIndex.TS става автоматично, веднага след като е създаден обект за контекст на съхранение.
-
-## [Персонализиран векторен индекс](https://github.com/run-llama/LlamaIndexTS/blob/main/examples/vectorIndexCustomize.ts)
-
-Създайте векторен индекс и го заявете, като конфигурирате `LLM`, `ServiceContext` и `similarity_top_k`.
-
-"
-
-## [OpenAI LLM](https://github.com/run-llama/LlamaIndexTS/blob/main/examples/openai.ts)
-
-Създайте OpenAI LLM и го използвайте директно за чат.
-
-## [Llama2 DeuceLLM](https://github.com/run-llama/LlamaIndexTS/blob/main/examples/llamadeuce.ts)
-
-Създайте Llama-2 LLM и го използвайте директно за чат.
-
-## [SubQuestionQueryEngine](https://github.com/run-llama/LlamaIndexTS/blob/main/examples/subquestion.ts)
-
-Използва `SubQuestionQueryEngine`, който разбива сложни заявки на множество въпроси и след това агрегира отговорите на всички под-въпроси.
-
-"
-
-## [Модули с ниско ниво](https://github.com/run-llama/LlamaIndexTS/blob/main/examples/lowlevel.ts)
-
-Този пример използва няколко компонента с ниско ниво, които премахват нуждата от реален двигател за заявки. Тези компоненти могат да се използват навсякъде, във всяко приложение или да бъдат персонализирани и подкласирани, за да отговарят на вашите нужди.
-
-"

apps/docs/i18n/bg/docusaurus-plugin-content-docs/current/environments.md

@@ -1,17 +0,0 @@
----
-sidebar_position: 5
----
-
-# Среди
-
-`Тази документация е преведена автоматично и може да съдържа грешки. Не се колебайте да отворите Pull Request, за да предложите промени.`
-
-LlamaIndex в момента официално поддържа NodeJS 18 и NodeJS 20.
-
-## NextJS App Router
-
-Ако използвате обработчици на маршрути/сървърни функции на NextJS App Router, ще трябва да използвате режима на NodeJS:
-
-```js
-export const runtime = "nodejs"; // по подразбиране
-```

apps/docs/i18n/bg/docusaurus-plugin-content-docs/current/installation.mdx

@@ -1,65 +0,0 @@
----
-sidebar_position: 1
----
-
-# Инсталация и настройка
-
-`Тази документация е преведена автоматично и може да съдържа грешки. Не се колебайте да отворите Pull Request, за да предложите промени.`
-
-Уверете се, че имате NodeJS v18 или по-нова версия.
-
-## Използване на create-llama
-
-Най-лесният начин да започнете с LlamaIndex е чрез използването на `create-llama`. Този инструмент с команден ред ви позволява бързо да започнете да създавате ново приложение LlamaIndex, като всичко е настроено за вас.
-
-Просто изпълнете
-
-<Tabs>
-<TabItem value="1" label="npm" default>
-
-```bash
-npx create-llama@latest
-```
-
-</TabItem>
-<TabItem value="2" label="Yarn">
-
-```bash
-yarn create llama
-```
-
-</TabItem>
-<TabItem value="3" label="pnpm">
-
-```bash
-pnpm create llama@latest
-```
-
-</TabItem>
-</Tabs>
-
-за да започнете. След като приложението ви е генерирано, изпълнете
-
-```bash npm2yarn
-npm run dev
-```
-
-за да стартирате сървъра за разработка. След това можете да посетите [http://localhost:3000](http://localhost:3000), за да видите вашето приложение.
-
-## Инсталация от NPM
-
-```bash npm2yarn
-npm install llamaindex
-```
-
-### Променливи на средата
-
-Нашият пример използва OpenAI по подразбиране. Ще трябва да настроите вашия Open AI ключ по следния начин:
-
-```bash
-export OPENAI_API_KEY="sk-......" # Заменете с вашия ключ от https://platform.openai.com/account/api-keys
-```
-
-Ако искате да го зареждате автоматично всеки път, добавете го към вашия .zshrc/.bashrc.
-
-ВНИМАНИЕ: не добавяйте вашия OpenAI ключ в системата за контрол на версиите.

apps/docs/i18n/bg/docusaurus-plugin-content-docs/current/introduction.md

@@ -1,62 +0,0 @@
----
-sidebar_position: 0
-slug: /
----
-
-# Какво е LlamaIndex.TS?
-
-`Тази документация е преведена автоматично и може да съдържа грешки. Не се колебайте да отворите Pull Request, за да предложите промени.`
-
-LlamaIndex.TS е рамка за данни за приложения на LLM, която позволява внасяне, структуриране и достъп до частни или специфични за домейна данни. Въпреки че има наличен и пакет на Python (вижте [тук](https://docs.llamaindex.ai/en/stable/)), LlamaIndex.TS предлага основни функции в едно просто пакетиране, оптимизирано за използване с TypeScript.
-
-## 🚀 Защо LlamaIndex.TS?
-
-В основата си, LLM-ите предлагат естествен езиков интерфейс между хората и изводените данни. Широко разпространените модели са предварително обучени на голямо количество публично достъпни данни, от Уикипедия и списания до учебници и изходен код.
-
-Приложенията, построени върху LLM-и, често изискват допълване на тези модели с частни или специфични за домейна данни. За съжаление, тези данни могат да бъдат разпределени в различни приложения и хранилища на данни. Те се намират зад API-и, в SQL бази данни или са затворени в PDF файлове и презентации.
-
-Тук идва **LlamaIndex.TS**.
-
-## 🦙 Как може да помогне LlamaIndex.TS?
-
-LlamaIndex.TS предоставя следните инструменти:
-
-- **Зареждане на данни** - внасяйте вашите съществуващи данни във формат `.txt`, `.pdf`, `.csv`, `.md` и `.docx` директно
-- **Индекси на данни** - структурирайте данните си в промежуточни представяния, които са лесни и ефективни за консумация от LLM.
-- **Двигатели** - предоставят достъп до вашите данни чрез естествен език. Например:
-  - Заявителни двигатели са мощни интерфейси за извличане на знания.
-  - Чат двигатели са разговорни интерфейси за многократни, "напред и назад" взаимодействия с вашите данни.
-
-"
-
-## 👨‍👩‍👧‍👦 За кого е LlamaIndex?
-
-LlamaIndex.TS предоставя основен набор от инструменти, необходими за всеки, който създава LLM приложения с JavaScript и TypeScript.
-
-Нашето API на високо ниво позволява на начинаещите потребители да използват LlamaIndex.TS за внасяне и заявка на техните данни.
-
-За по-сложни приложения нашите API на по-ниско ниво позволяват на напредналите потребители да персонализират и разширят всяко модул - връзки с данни, индекси, извличатели и заявки, за да отговарят на техните нужди.
-
-## Започване
-
-`npm install llamaindex`
-
-Документацията ни включва [Инструкции за инсталиране](./installation.mdx) и [Урок за начинаещи](./starter.md), за да построите първото си приложение.
-
-След като сте готови, [Високо ниво концепции](./getting_started/concepts.md) представя общ преглед на модулната архитектура на LlamaIndex. За повече практически примери, разгледайте нашите [Уроци от начало до край](./end_to_end.md).
-
-## 🗺️ Екосистема
-
-За да изтеглите или допринесете, намерете LlamaIndex на:
-
-- Github: https://github.com/run-llama/LlamaIndexTS
-- NPM: https://www.npmjs.com/package/llamaindex
-
-"
-
-## Общност
-
-Нуждаете се от помощ? Имате предложение за функционалност? Присъединете се към общността на LlamaIndex:
-
-- Twitter: https://twitter.com/llama_index
-- Discord: https://discord.gg/dGcwcsnxhU

apps/docs/i18n/bg/docusaurus-plugin-content-docs/current/modules/high_level/chat_engine.md

@@ -1,24 +0,0 @@
----
-sidebar_position: 4
----
-
-# Чат двигател (ChatEngine)
-
-`Тази документация е преведена автоматично и може да съдържа грешки. Не се колебайте да отворите Pull Request, за да предложите промени.`
-
-Чат двигателят е бърз и прост начин да чатите с данните във вашата индекс.
-
-```typescript
-const retriever = index.asRetriever();
-const chatEngine = new ContextChatEngine({ retriever });
-
-// започнете да чатите
-const response = await chatEngine.chat(query);
-```
-
-## Api Референции
-
-- [Чат двигател за контекст (ContextChatEngine)](../../api/classes/ContextChatEngine.md)
-- [Чат двигател за кондензиране на въпроси (CondenseQuestionChatEngine)](../../api/classes/ContextChatEngine.md)
-
-"

apps/docs/i18n/bg/docusaurus-plugin-content-docs/current/modules/high_level/data_index.md

@@ -1,27 +0,0 @@
----
-sidebar_position: 2
----
-
-# Индекс
-
-`Тази документация е преведена автоматично и може да съдържа грешки. Не се колебайте да отворите Pull Request, за да предложите промени.`
-
-Индексът е основният контейнер и организация за вашите данни. LlamaIndex.TS поддържа два вида индекси:
-
-- `VectorStoreIndex` - ще изпраща най-добрите `Node` до LLM при генериране на отговор. По подразбиране, най-добрите два.
-- `SummaryIndex` - ще изпраща всеки `Node` в индекса до LLM, за да генерира отговор.
-
-```typescript
-import { Document, VectorStoreIndex } from "llamaindex";
-
-const document = new Document({ text: "тест" });
-
-const index = await VectorStoreIndex.fromDocuments([document]);
-```
-
-## API Референция
-
-- [SummaryIndex](../../api/classes/SummaryIndex.md)
-- [VectorStoreIndex](../../api/classes/VectorStoreIndex.md)
-
-"

apps/docs/i18n/bg/docusaurus-plugin-content-docs/current/modules/high_level/data_loader.md

@@ -1,21 +0,0 @@
----
-sidebar_position: 1
----
-
-# Четец / Зареждач
-
-`Тази документация е преведена автоматично и може да съдържа грешки. Не се колебайте да отворите Pull Request, за да предложите промени.`
-
-LlamaIndex.TS поддържа лесно зареждане на файлове от папки с помощта на класа `SimpleDirectoryReader`. В момента се поддържат файлове с разширения `.txt`, `.pdf`, `.csv`, `.md` и `.docx`, с планове за добавяне на още в бъдеще!
-
-```typescript
-import { SimpleDirectoryReader } from "llamaindex";
-
-documents = new SimpleDirectoryReader().loadData("./data");
-```
-
-## API Референция
-
-- [SimpleDirectoryReader](../../api/classes/SimpleDirectoryReader.md)
-
-"

apps/docs/i18n/bg/docusaurus-plugin-content-docs/current/modules/high_level/documents_and_nodes.md

@@ -1,22 +0,0 @@
----
-sidebar_position: 0
----
-
-# Документи и Възли
-
-`Тази документация е преведена автоматично и може да съдържа грешки. Не се колебайте да отворите Pull Request, за да предложите промени.`
-
-`Документи` и `Възли` са основните строителни блокове на всяко индексиране. Въпреки че API-то за тези обекти е подобно, обектите `Документ` представляват цели файлове, докато `Възли` са по-малки части от оригиналния документ, които са подходящи за LLM и Q&A.
-
-```typescript
-import { Document } from "llamaindex";
-
-document = new Document({ text: "текст", metadata: { key: "val" } });
-```
-
-## API Референция
-
-- [Документ](../../api/classes/Document.md)
-- [ТекстовВъзел](../../api/classes/TextNode.md)
-
-"

apps/docs/i18n/bg/docusaurus-plugin-content-docs/current/modules/high_level/query_engine.md

@@ -1,40 +0,0 @@
----
-sidebar_position: 3
----
-
-# QueryEngine (Заявка на двигател)
-
-`Тази документация е преведена автоматично и може да съдържа грешки. Не се колебайте да отворите Pull Request, за да предложите промени.`
-
-Заявка на двигател обвива `Retriever` и `ResponseSynthesizer` в тръбопровод, който използва низа от заявки, за да извлече възли и след това ги изпраща към LLM, за да генерира отговор.
-
-```typescript
-const queryEngine = index.asQueryEngine();
-const response = await queryEngine.query("query string");
-```
-
-## Заявка на подзапитване на двигател
-
-Основната концепция на Заявка на подзапитване на двигател е, че тя разделя една заявка на множество заявки, получава отговор за всяка от тези заявки и след това комбинира тези различни отговори в един цялостен отговор за потребителя. Можете да си представите това като техника за "мислене стъпка по стъпка", но като итерира върху източниците на данни!
-
-### Започване
-
-Най-лесният начин да започнете да използвате Заявка на подзапитване на двигател е да стартирате файла subquestion.ts в [примерите](https://github.com/run-llama/LlamaIndexTS/blob/main/examples/subquestion.ts).
-
-```bash
-npx ts-node subquestion.ts
-```
-
-### Инструменти
-
-Заявка на подзапитване на двигател е реализирана с инструменти. Основната идея на инструментите е, че те са изпълними опции за големия езиков модел. В този случай нашият Заявка на подзапитване на двигател разчита на QueryEngineTool, който, както се предполага, е инструмент за изпълнение на заявки върху QueryEngine. Това ни позволява да дадем на модела възможност да заявява различни документи за различни въпроси, например. Също така можем да си представим, че Заявка на подзапитване на двигател може да използва инструмент, който търси нещо в Интернет или получава отговор, използвайки Wolfram Alpha.
-
-Можете да научите повече за инструментите, като разгледате документацията на LlamaIndex Python https://gpt-index.readthedocs.io/en/latest/core_modules/agent_modules/tools/root.html
-
-## API Reference (API справка)
-
-- [RetrieverQueryEngine (Заявка на двигател за извличане)](../../api/classes/RetrieverQueryEngine.md)
-- [SubQuestionQueryEngine (Заявка на двигател за подзапитване)](../../api/classes/SubQuestionQueryEngine.md)
-- [QueryEngineTool (Инструмент за заявка на двигател)](../../api/interfaces/QueryEngineTool.md)
-
-"

apps/docs/i18n/bg/docusaurus-plugin-content-docs/current/modules/index.md

@@ -1,33 +0,0 @@
-# Основни модули
-
-`Тази документация е преведена автоматично и може да съдържа грешки. Не се колебайте да отворите Pull Request, за да предложите промени.`
-
-LlamaIndex.TS предлага няколко основни модула, разделени на модули на високо ниво, за бързо стартиране, и модули на ниско ниво, за персонализиране на ключовите компоненти според вашите нужди.
-
-## Модули на високо ниво
-
-- [**Документ**](./high_level/documents_and_nodes.md): Документ представлява текстов файл, PDF файл или друг непрекъснат парче данни.
-
-- [**Възел**](./high_level/documents_and_nodes.md): Основният строителен блок от данни. Най-често това са части от документа, разделени на управляеми парчета, достатъчно малки, за да бъдат подадени на модел за вграждане и LLM.
-
-- [**Четец/Зареждач**](./high_level/data_loader.md): Четецът или зареждачът е нещо, което приема документ от реалния свят и го преобразува в клас Документ, който после може да се използва в индекса и заявките ви. В момента поддържаме обикновени текстови файлове и PDF файлове, с много други, които ще бъдат добавени.
-
-- [**Индекси**](./high_level/data_index.md): Индексите съхраняват Възлите и вгражданията на тези възли.
-
-- [**QueryEngine**](./high_level/query_engine.md): Заявките са това, което генерира заявката, която въвеждате и ви връща резултата. Заявките обикновено комбинират предварително изграден prompt със избрани възли от вашия индекс, за да предоставят на LLM контекста, от който се нуждае, за да отговори на вашата заявка.
-
-- [**ChatEngine**](./high_level/chat_engine.md): ChatEngine ви помага да построите чатбот, който ще взаимодейства с вашите индекси.
-
-## Модули на ниско ниво
-
-- [**LLM**](./low_level/llm.md): Класът LLM е обединен интерфейс над голям доставчик на модели на езика като OpenAI GPT-4, Anthropic Claude или Meta LLaMA. Можете да го наследите, за да напишете конектор към собствен модел на голям език.
-
-- [**Embedding**](./low_level/embedding.md): Вграждането се представя като вектор от числа с плаваща запетая. Нашето вграждане по подразбиране е OpenAI's text-embedding-ada-002 и всяко вграждане, което генерира, се състои от 1,536 числа с плаваща запетая. Друго популярно вграждане е BERT, което използва 768 числа с плаваща запетая, за да представи всеки възел. Предоставяме няколко помощни функции за работа с вграждания, включително 3 опции за изчисляване на подобие и Maximum Marginal Relevance.
-
-- [**TextSplitter/NodeParser**](./low_level/node_parser.md): Стратегиите за разделяне на текст са изключително важни за общата ефективност на търсенето на вграждания. В момента, въпреки че имаме стойност по подразбиране, няма универсално решение. В зависимост от източниците на документите, може да искате да използвате различни размери и стратегии за разделяне. В момента поддържаме разделяне по фиксиран размер, разделяне по фиксиран размер с препокриващи се секции, разделяне по изречение и разделяне по параграф. TextSplitter се използва от NodeParser при разделянето на `Document` на `Node`.
-
-- [**Retriever**](./low_level/retriever.md): Retriever е този, който наистина избира възлите за връщане от индекса. Тук може да желаете да опитате да вземете повече или по-малко възли за всяка заявка, да промените функцията за подобие или да създадете собствен retriever за всеки отделен случай в приложението си. Например може да желаете да имате отделен retriever за съдържание на код срещу текстово съдържание.
-
-- [**ResponseSynthesizer**](./low_level/response_synthesizer.md): ResponseSynthesizer е отговорен за вземането на низ от заявка и използването на списък от `Node`-и за генериране на отговор. Това може да бъде в различни форми, като обхождане на всички контексти и уточняване на отговор, или изграждане на дърво от резюмета и връщане на кореновото резюме.
-
-- [**Storage**](./low_level/storage.md): На някакъв етап ще искате да съхранявате индексите, данните и векторите си, вместо да изпълнявате моделите за вграждане всеки път. IndexStore, DocStore, VectorStore и KVStore са абстракции, които ви позволяват да го направите. Заедно те формират StorageContext. В момента ви позволяваме да запазвате вгражданията си във файлове на файловата система (или виртуална файлова система в паметта), но също така активно добавяме интеграции към Vector Databases.

apps/docs/i18n/bg/docusaurus-plugin-content-docs/current/modules/low_level/embedding.md

@@ -1,26 +0,0 @@
----
-sidebar_position: 1
----
-
-# Вграждане (Embedding)
-
-`Тази документация е преведена автоматично и може да съдържа грешки. Не се колебайте да отворите Pull Request, за да предложите промени.`
-
-Моделът за вграждане в LlamaIndex е отговорен за създаването на числови представяния на текст. По подразбиране, LlamaIndex използва модела `text-embedding-ada-002` от OpenAI.
-
-Това може да бъде явно зададено в обекта `ServiceContext`.
-
-```typescript
-import { OpenAIEmbedding, serviceContextFromDefaults } from "llamaindex";
-
-const openaiEmbeds = new OpenAIEmbedding();
-
-const serviceContext = serviceContextFromDefaults({ embedModel: openaiEmbeds });
-```
-
-## API Референция
-
-- [OpenAIEmbedding](../../api/classes/OpenAIEmbedding.md)
-- [ServiceContext](../../api/interfaces/ServiceContext.md)
-
-"

apps/docs/i18n/bg/docusaurus-plugin-content-docs/current/modules/low_level/llm.md

@@ -1,26 +0,0 @@
----
-sidebar_position: 0
----
-
-# LLM
-
-`Тази документация е преведена автоматично и може да съдържа грешки. Не се колебайте да отворите Pull Request, за да предложите промени.`
-
-LLM е отговорен за четене на текст и генериране на отговори на естествен език на заявки. По подразбиране, LlamaIndex.TS използва `gpt-3.5-turbo`.
-
-LLM може да бъде явно зададен в обекта `ServiceContext`.
-
-```typescript
-import { OpenAI, serviceContextFromDefaults } from "llamaindex";
-
-const openaiLLM = new OpenAI({ model: "gpt-3.5-turbo", temperature: 0 });
-
-const serviceContext = serviceContextFromDefaults({ llm: openaiLLM });
-```
-
-## API Референция
-
-- [OpenAI](../../api/classes/OpenAI.md)
-- [ServiceContext](../../api/interfaces/ServiceContext.md)
-
-"

apps/docs/i18n/bg/docusaurus-plugin-content-docs/current/modules/low_level/node_parser.md

@@ -1,37 +0,0 @@
----
-sidebar_position: 3
----
-
-# NodeParser (Анализатор на възли)
-
-`Тази документация е преведена автоматично и може да съдържа грешки. Не се колебайте да отворите Pull Request, за да предложите промени.`
-
-`NodeParser` в LlamaIndex е отговорен за разделянето на обекти от тип `Document` на по-лесни за управление обекти от тип `Node`. Когато извикате `.fromDocuments()`, `NodeParser` от `ServiceContext` се използва автоматично за това. Алтернативно, можете да го използвате, за да разделяте документи предварително.
-
-```typescript
-import { Document, SimpleNodeParser } from "llamaindex";
-
-const nodeParser = new SimpleNodeParser();
-const nodes = nodeParser.getNodesFromDocuments([
-  new Document({ text: "Аз съм на 10 години. Джон е на 20 години." }),
-]);
-```
-
-## TextSplitter (TextSplitter)
-
-Основният разделящ текст ще раздели текста на изречения. Той може също да се използва като самостоятелен модул за разделяне на суров текст.
-
-```typescript
-import { SentenceSplitter } from "llamaindex";
-
-const splitter = new SentenceSplitter({ chunkSize: 1 });
-
-const textSplits = splitter.splitText("Здравей, свят");
-```
-
-## API Reference (API справка)
-
-- [SimpleNodeParser (Прост анализатор на възли)](../../api/classes/SimpleNodeParser.md)
-- [SentenceSplitter (Разделяне на изречения)](../../api/classes/SentenceSplitter.md)
-
-"

apps/docs/i18n/bg/docusaurus-plugin-content-docs/current/modules/low_level/response_synthesizer.md

@@ -1,47 +0,0 @@
----
-sidebar_position: 6
----
-
-# ResponseSynthesizer (Синтезатор на отговори)
-
-`Тази документация е преведена автоматично и може да съдържа грешки. Не се колебайте да отворите Pull Request, за да предложите промени.`
-
-ResponseSynthesizer е отговорен за изпращането на заявката, възлите и шаблоните за подсказки към LLM, за да генерира отговор. Има няколко ключови режима за генериране на отговор:
-
-- `Refine` (Подобряване): "създаване и подобряване" на отговор, като последователно се преминава през всеки извлечен текстов фрагмент. Това прави отделно LLM обаждане за всеки възел. Подходящо за по-подробни отговори.
-- `CompactAndRefine` (Компактно и подобряване) (по подразбиране): "компактиране" на подсказката по време на всяко LLM обаждане, като се пълни с колкото може повече текстови фрагменти, които могат да се поберат в максималния размер на подсказката. Ако има твърде много фрагменти, които не могат да се поберат в една подсказка, се "създава и подобрява" отговор, като се преминава през няколко компактни подсказки. Същото като `refine`, но трябва да доведе до по-малко LLM обаждания.
-- `TreeSummarize` (Сумиране на дърво): Дадени набор от текстови фрагменти и заявката, рекурсивно се конструира дърво и се връща кореновият възел като отговор. Подходящо за цели на сумиране.
-- `SimpleResponseBuilder` (Прост създател на отговори): Дадени набор от текстови фрагменти и заявката, се прилага заявката към всеки текстов фрагмент, като се натрупват отговорите в масив. Връща конкатениран низ от всички отговори. Подходящо, когато трябва да изпълните същата заявка отделно за всеки текстов фрагмент.
-
-```typescript
-import { NodeWithScore, ResponseSynthesizer, TextNode } from "llamaindex";
-
-const responseSynthesizer = new ResponseSynthesizer();
-
-const nodesWithScore: NodeWithScore[] = [
-  {
-    node: new TextNode({ text: "Аз съм на 10 години." }),
-    score: 1,
-  },
-  {
-    node: new TextNode({ text: "Джон е на 20 години." }),
-    score: 0.5,
-  },
-];
-
-const response = await responseSynthesizer.synthesize(
-  "Колко години съм?",
-  nodesWithScore,
-);
-console.log(response.response);
-```
-
-## API Референция
-
-- [ResponseSynthesizer (Синтезатор на отговори)](../../api/classes/ResponseSynthesizer.md)
-- [Refine (Подобряване)](../../api/classes/Refine.md)
-- [CompactAndRefine (Компактно и подобряване)](../../api/classes/CompactAndRefine.md)
-- [TreeSummarize (Сумиране на дърво)](../../api/classes/TreeSummarize.md)
-- [SimpleResponseBuilder (Прост създател на отговори)](../../api/classes/SimpleResponseBuilder.md)
-
-"

apps/docs/i18n/bg/docusaurus-plugin-content-docs/current/modules/low_level/retriever.md

@@ -1,25 +0,0 @@
----
-sidebar_position: 5
----
-
-# Retriever (Извличател)
-
-`Тази документация е преведена автоматично и може да съдържа грешки. Не се колебайте да отворите Pull Request, за да предложите промени.`
-
-Извличател в LlamaIndex е това, което се използва за извличане на `Node` от индекс чрез заявка. `VectorIndexRetriever` ще извлече най-подобните k върха. В същото време, `SummaryIndexRetriever` ще извлече всички върхове, независимо от заявката.
-
-```typescript
-const retriever = vector_index.asRetriever();
-retriever.similarityTopK = 3;
-
-// Извличане на върхове!
-const nodesWithScore = await retriever.retrieve({ query: "query string" });
-```
-
-## API Reference (API справка)
-
-- [SummaryIndexRetriever](../../api/classes/SummaryIndexRetriever.md)
-- [SummaryIndexLLMRetriever](../../api/classes/SummaryIndexLLMRetriever.md)
-- [VectorIndexRetriever](../../api/classes/VectorIndexRetriever.md)
-
-"

apps/docs/i18n/bg/docusaurus-plugin-content-docs/current/modules/low_level/storage.md

@@ -1,30 +0,0 @@
----
-sidebar_position: 7
----
-
-# Съхранение (Storage)
-
-`Тази документация е преведена автоматично и може да съдържа грешки. Не се колебайте да отворите Pull Request, за да предложите промени.`
-
-Съхранението в LlamaIndex.TS работи автоматично, след като сте конфигурирали обект `StorageContext`. Просто конфигурирайте `persistDir` и го свържете с индекс.
-
-В момента се поддържа само запазване и зареждане от диск, с планирани бъдещи интеграции!
-
-```typescript
-import { Document, VectorStoreIndex, storageContextFromDefaults } from "./src";
-
-const storageContext = await storageContextFromDefaults({
-  persistDir: "./storage",
-});
-
-const document = new Document({ text: "Тестов текст" });
-const index = await VectorStoreIndex.fromDocuments([document], {
-  storageContext,
-});
-```
-
-## API Референция
-
-- [StorageContext](../../api/interfaces/StorageContext.md)
-
-"

apps/docs/i18n/bg/docusaurus-plugin-content-docs/current/starter.md

@@ -1,60 +0,0 @@
----
-sidebar_position: 2
----
-
-# Начално ръководство
-
-`Тази документация е преведена автоматично и може да съдържа грешки. Не се колебайте да отворите Pull Request, за да предложите промени.`
-
-След като сте [инсталирали LlamaIndex.TS с помощта на NPM](installation) и сте настроили вашия OpenAI ключ, вие сте готови да стартирате първото си приложение:
-
-В нова папка:
-
-```bash npm2yarn
-npm install typescript
-npm install @types/node
-npx tsc --init # ако е необходимо
-```
-
-Създайте файла `example.ts`. Този код ще зареди някакви примерни данни, ще създаде документ, ще го индексира (което създава вграждания с помощта на OpenAI) и след това ще създаде търсачка, която да отговаря на въпроси относно данните.
-
-```ts
-// example.ts
-import fs from "fs/promises";
-import { Document, VectorStoreIndex } from "llamaindex";
-
-async function main() {
-  // Заредете есе от abramov.txt в Node
-  const essay = await fs.readFile(
-    "node_modules/llamaindex/examples/abramov.txt",
-    "utf-8",
-  );
-
-  // Създайте обект Document с есето
-  const document = new Document({ text: essay });
-
-  // Разделете текста и създайте вграждания. Запазете ги в VectorStoreIndex
-  const index = await VectorStoreIndex.fromDocuments([document]);
-
-  // Заявете индекса
-  const queryEngine = index.asQueryEngine();
-  const response = await queryEngine.query(
-    "Какво направи авторът по време на колеж?",
-  );
-
-  // Изведете отговора
-  console.log(response.toString());
-}
-
-main();
-```
-
-След това можете да го стартирате чрез
-
-```bash
-npx ts-node example.ts
-```
-
-Готови ли сте да научите още? Проверете нашия NextJS игрален площад на адрес https://llama-playground.vercel.app/. Изходният код е достъпен на адрес https://github.com/run-llama/ts-playground
-
-"

apps/docs/i18n/cat/docusaurus-plugin-content-docs/current/api

@@ -1 +0,0 @@
-../../../../docs/api

apps/docs/i18n/cat/docusaurus-plugin-content-docs/current/concepts.md

@@ -1,86 +0,0 @@
----
-sidebar_position: 3
----
-
-# Conceptes de Nivell Alt
-
-`Aquesta documentació s'ha traduït automàticament i pot contenir errors. No dubteu a obrir una Pull Request per suggerir canvis.`
-
-LlamaIndex.TS t'ajuda a construir aplicacions amb potència LLM (per exemple, Q&A, chatbot) sobre dades personalitzades.
-
-En aquesta guia de conceptes de nivell alt, aprendràs:
-
-- com un LLM pot respondre preguntes utilitzant les teves pròpies dades.
-- conceptes clau i mòduls en LlamaIndex.TS per compondre la teva pròpia canalització de consulta.
-
-## Resposta a preguntes a través de les teves dades
-
-LlamaIndex utilitza un mètode de dues etapes quan utilitza un LLM amb les teves dades:
-
-1. **etapa d'indexació**: preparació d'una base de coneixement, i
-2. **etapa de consulta**: recuperació de context rellevant de la base de coneixement per ajudar el LLM a respondre a una pregunta
-
-![](./_static/concepts/rag.jpg)
-
-Aquest procés també és conegut com a Generació Augmentada per Recuperació (RAG).
-
-LlamaIndex.TS proporciona les eines essencials per facilitar ambdós passos.
-
-Explorarem cada etapa en detall.
-
-### Etapa d'Indexació
-
-LlamaIndex.TS t'ajuda a preparar la base de coneixement amb una sèrie de connectors de dades i índexs.
-
-![](./_static/concepts/indexing.jpg)
-
-[**Carregadors de Dades**](./modules/high_level/data_loader.md):
-Un connector de dades (és a dir, `Reader`) ingestiona dades de diferents fonts de dades i formats de dades en una representació simple de `Document` (text i metadades simples).
-
-[**Documents / Nodes**](./modules/high_level/documents_and_nodes.md): Un `Document` és un contenidor genèric al voltant de qualsevol font de dades - per exemple, un PDF, una sortida d'API o dades recuperades d'una base de dades. Un `Node` és la unitat atòmica de dades en LlamaIndex i representa un "tros" d'un `Document` origen. És una representació completa que inclou metadades i relacions (amb altres nodes) per permetre operacions de recuperació precises i expressives.
-
-[**Índexs de Dades**](./modules/high_level/data_index.md):
-Un cop hagis ingestat les teves dades, LlamaIndex t'ajuda a indexar les dades en un format fàcil de recuperar.
-
-A sota dels panells, LlamaIndex analitza els documents en representacions intermèdies, calcula incrustacions vectorials i emmagatzema les teves dades a la memòria o al disc.
-
-"
-
-### Etapa de Consulta
-
-En l'etapa de consulta, la canalització de consulta recupera el context més rellevant donada una consulta de l'usuari,
-i ho passa al LLM (juntament amb la consulta) per sintetitzar una resposta.
-
-Això proporciona al LLM un coneixement actualitzat que no es troba en les seves dades d'entrenament originals,
-(i també redueix la al·lucinació).
-
-El repte clau en l'etapa de consulta és la recuperació, l'orquestració i el raonament sobre bases de coneixement (potencialment moltes).
-
-LlamaIndex proporciona mòduls componibles que t'ajuden a construir i integrar canalitzacions RAG per a Q&A (motor de consulta), chatbot (motor de xat) o com a part d'un agent.
-
-Aquests blocs de construcció es poden personalitzar per reflectir les preferències de classificació, així com compondre el raonament sobre múltiples bases de coneixement de manera estructurada.
-
-![](./_static/concepts/querying.jpg)
-
-#### Blocs de Construcció
-
-[**Recuperadors**](./modules/low_level/retriever.md):
-Un recuperador defineix com recuperar eficientment el context rellevant d'una base de coneixement (és a dir, índex) quan se li dóna una consulta.
-La lògica de recuperació específica difereix per a diferents índexs, sent la més popular la recuperació densa contra un índex vectorial.
-
-[**Sintetitzadors de Resposta**](./modules/low_level/response_synthesizer.md):
-Un sintetitzador de resposta genera una resposta a partir d'un LLM, utilitzant una consulta de l'usuari i un conjunt donat de trossos de text recuperats.
-
-"
-
-#### Canalitzacions
-
-[**Motor de Consulta**](./modules/high_level/query_engine.md):
-Un motor de consulta és una canalització de cap a cap que et permet fer preguntes sobre les teves dades.
-Rebutja una consulta en llenguatge natural i retorna una resposta, juntament amb el context de referència recuperat i passat al LLM.
-
-[**Motor de Xat**](./modules/high_level/chat_engine.md):
-Un motor de xat és una canalització de cap a cap per mantenir una conversa amb les teves dades
-(múltiples intercanvis en lloc d'una única pregunta i resposta).
-
-"

apps/docs/i18n/cat/docusaurus-plugin-content-docs/current/end_to_end.md

@@ -1,59 +0,0 @@
----
-sidebar_position: 4
----
-
-# Exemples de principi a fi
-
-`Aquesta documentació s'ha traduït automàticament i pot contenir errors. No dubteu a obrir una Pull Request per suggerir canvis.`
-
-Incluïm diversos exemples de principi a fi utilitzant LlamaIndex.TS en el repositori.
-
-Comproveu els exemples a continuació o proveu-los i completeu-los en qüestió de minuts amb els tutorials interactius de Github Codespace proporcionats per Dev-Docs [aquí](https://codespaces.new/team-dev-docs/lits-dev-docs-playground?devcontainer_path=.devcontainer%2Fjavascript_ltsquickstart%2Fdevcontainer.json):
-
-## [Motor de xat](https://github.com/run-llama/LlamaIndexTS/blob/main/examples/chatEngine.ts)
-
-Llegeix un fitxer i xerra sobre això amb el LLM.
-
-## [Índex de vectors](https://github.com/run-llama/LlamaIndexTS/blob/main/examples/vectorIndex.ts)
-
-Creeu un índex de vectors i consulteu-lo. L'índex de vectors utilitzarà incrustacions per obtenir els nodes més rellevants més importants. Per defecte, els nodes més importants són 2.
-
-"
-
-## [Índex de resum](https://github.com/run-llama/LlamaIndexTS/blob/main/examples/summaryIndex.ts)
-
-Creeu un índex de llista i consulteu-lo. Aquest exemple també utilitza el `LLMRetriever`, que utilitzarà el LLM per seleccionar els millors nodes a utilitzar en la generació de la resposta.
-
-"
-
-## [Guardar / Carregar un Índex](https://github.com/run-llama/LlamaIndexTS/blob/main/examples/storageContext.ts)
-
-Creeu i carregueu un índex de vectors. La persistència al disc en LlamaIndex.TS es produeix automàticament una vegada que es crea un objecte de context d'emmagatzematge.
-
-## [Índex de vectors personalitzat](https://github.com/run-llama/LlamaIndexTS/blob/main/examples/vectorIndexCustomize.ts)
-
-Creeu un índex de vectors i consulteu-lo, mentre configureu el `LLM`, el `ServiceContext` i el `similarity_top_k`.
-
-## [OpenAI LLM](https://github.com/run-llama/LlamaIndexTS/blob/main/examples/openai.ts)
-
-Crea un OpenAI LLM i utilitza'l directament per a xatejar.
-
-"
-
-## [Llama2 DeuceLLM](https://github.com/run-llama/LlamaIndexTS/blob/main/examples/llamadeuce.ts)
-
-Crea un Llama-2 LLM i utilitza'l directament per a xatejar.
-
-"
-
-## [Motor de consulta de subpreguntes](https://github.com/run-llama/LlamaIndexTS/blob/main/examples/subquestion.ts)
-
-Utilitza el `Motor de consulta de subpreguntes`, que descompon les consultes complexes en múltiples preguntes i després agrega una resposta a través de les respostes a totes les subpreguntes.
-
-"
-
-## [Mòduls de baix nivell](https://github.com/run-llama/LlamaIndexTS/blob/main/examples/lowlevel.ts)
-
-Aquest exemple utilitza diversos components de baix nivell, el que elimina la necessitat d'un motor de consulta real. Aquests components es poden utilitzar en qualsevol lloc, en qualsevol aplicació, o personalitzar i sub-classificar per satisfer les vostres pròpies necessitats.
-
-"

apps/docs/i18n/cat/docusaurus-plugin-content-docs/current/environments.md

@@ -1,17 +0,0 @@
----
-sidebar_position: 5
----
-
-# Entorns
-
-`Aquesta documentació s'ha traduït automàticament i pot contenir errors. No dubteu a obrir una Pull Request per suggerir canvis.`
-
-LlamaIndex actualment suporta oficialment NodeJS 18 i NodeJS 20.
-
-## Enrutador d'aplicacions NextJS
-
-Si utilitzeu els gestors de rutes/funcions sense servidor de l'enrutador d'aplicacions NextJS, haureu d'utilitzar el mode NodeJS:
-
-```js
-export const runtime = "nodejs"; // per defecte
-```

apps/docs/i18n/cat/docusaurus-plugin-content-docs/current/installation.mdx

@@ -1,65 +0,0 @@
----
-sidebar_position: 1
----
-
-# Instal·lació i configuració
-
-`Aquesta documentació s'ha traduït automàticament i pot contenir errors. No dubteu a obrir una Pull Request per suggerir canvis.`
-
-Assegureu-vos de tenir NodeJS v18 o superior.
-
-## Utilitzant create-llama
-
-La manera més senzilla de començar amb LlamaIndex és utilitzant `create-llama`. Aquesta eina de línia de comandes us permet començar ràpidament a construir una nova aplicació LlamaIndex, amb tot configurat per a vosaltres.
-
-Simplement executeu
-
-<Tabs>
-<TabItem value="1" label="npm" default>
-
-```bash
-npx create-llama@latest
-```
-
-</TabItem>
-<TabItem value="2" label="Yarn">
-
-```bash
-yarn create llama
-```
-
-</TabItem>
-<TabItem value="3" label="pnpm">
-
-```bash
-pnpm create llama@latest
-```
-
-</TabItem>
-</Tabs>
-
-per començar. Un cop la vostra aplicació estigui generada, executeu
-
-```bash npm2yarn
-npm run dev
-```
-
-per iniciar el servidor de desenvolupament. A continuació, podeu visitar [http://localhost:3000](http://localhost:3000) per veure la vostra aplicació.
-
-## Instal·lació des de NPM
-
-```bash npm2yarn
-npm install llamaindex
-```
-
-### Variables d'entorn
-
-Els nostres exemples utilitzen OpenAI per defecte. Hauràs de configurar la teva clau d'Open AI de la següent manera:
-
-```bash
-export OPENAI_API_KEY="sk-......" # Reemplaça amb la teva clau de https://platform.openai.com/account/api-keys
-```
-
-Si vols que es carregui automàticament cada vegada, afegiu-la al teu .zshrc/.bashrc.
-
-ADVERTÈNCIA: no afegiu la vostra clau d'OpenAI al control de versions.

apps/docs/i18n/cat/docusaurus-plugin-content-docs/current/introduction.md

@@ -1,60 +0,0 @@
----
-sidebar_position: 0
-slug: /
----
-
-# Què és LlamaIndex.TS?
-
-`Aquesta documentació s'ha traduït automàticament i pot contenir errors. No dubteu a obrir una Pull Request per suggerir canvis.`
-
-LlamaIndex.TS és un marc de dades per a aplicacions LLM per a ingestió, estructuració i accés a dades privades o específiques del domini. Tot i que també hi ha un paquet de Python disponible (vegeu [aquí](https://docs.llamaindex.ai/en/stable/)), LlamaIndex.TS ofereix funcionalitats principals en un paquet senzill, optimitzat per a l'ús amb TypeScript.
-
-## 🚀 Per què LlamaIndex.TS?
-
-En el seu nucli, els LLM ofereixen una interfície de llenguatge natural entre els humans i les dades inferides. Els models àmpliament disponibles estan preentrenats amb grans quantitats de dades disponibles públicament, des de Wikipedia i llistes de correu fins a llibres de text i codi font.
-
-Les aplicacions construïdes sobre els LLM sovint requereixen augmentar aquests models amb dades privades o específiques del domini. Desafortunadament, aquestes dades es poden trobar distribuïdes en aplicacions i emmagatzematges de dades aïllats. Es troben darrere d'APIs, en bases de dades SQL o atrapades en PDFs i presentacions.
-
-Aquí és on entra en joc **LlamaIndex.TS**.
-
-## 🦙 Com pot ajudar LlamaIndex.TS?
-
-LlamaIndex.TS proporciona les següents eines:
-
-- **Càrrega de dades** per a la ingestió directa de les vostres dades en format `.txt`, `.pdf`, `.csv`, `.md` i `.docx`.
-- **Índexs de dades** per a l'estructuració de les vostres dades en representacions intermèdies que siguin fàcils i eficients per als LLM per a consumir.
-- **Motors** que proporcionen accés en llenguatge natural a les vostres dades. Per exemple:
-  - Els motors de consulta són interfícies de recuperació potents per a una sortida augmentada de coneixement.
-  - Els motors de xat són interfícies conversacionals per a interaccions de "anar i venir" amb múltiples missatges amb les vostres dades.
-
-## 👨‍👩‍👧‍👦 Per a qui és LlamaIndex?
-
-LlamaIndex.TS proporciona un conjunt d'eines bàsiques essencials per a qualsevol persona que construeixi aplicacions LLM amb JavaScript i TypeScript.
-
-La nostra API de nivell superior permet als usuaris principiants utilitzar LlamaIndex.TS per a la ingestió i consulta de les seves dades.
-
-Per a aplicacions més complexes, les nostres API de nivell inferior permeten als usuaris avançats personalitzar i ampliar qualsevol mòdul: connectors de dades, índexs, recuperadors i motors de consulta, per adaptar-se a les seves necessitats.
-
-## Començar
-
-`npm install llamaindex`
-
-La nostra documentació inclou [Instruccions d'Instal·lació](./installation.mdx) i un [Tutorial d'Inici](./starter.md) per a construir la vostra primera aplicació.
-
-Un cop tingueu tot a punt, [Conceptes de Nivell Alt](./getting_started/concepts.md) ofereix una visió general de l'arquitectura modular de LlamaIndex. Per a més exemples pràctics, consulteu els nostres [Tutorials de Principi a Fi](./end_to_end.md).
-
-## 🗺️ Ecosistema
-
-Per descarregar o contribuir, troba LlamaIndex a:
-
-- Github: https://github.com/run-llama/LlamaIndexTS
-- NPM: https://www.npmjs.com/package/llamaindex
-
-"
-
-## Comunitat
-
-Necessiteu ajuda? Teniu alguna suggerència de funcionalitat? Uneix-te a la comunitat de LlamaIndex:
-
-- Twitter: https://twitter.com/llama_index
-- Discord: https://discord.gg/dGcwcsnxhU

apps/docs/i18n/cat/docusaurus-plugin-content-docs/current/modules/high_level/chat_engine.md

@@ -1,22 +0,0 @@
----
-sidebar_position: 4
----
-
-# ChatEngine (Motor de Xat)
-
-`Aquesta documentació s'ha traduït automàticament i pot contenir errors. No dubteu a obrir una Pull Request per suggerir canvis.`
-
-El motor de xat és una manera ràpida i senzilla de xatejar amb les dades del teu índex.
-
-```typescript
-const retriever = index.asRetriever();
-const chatEngine = new ContextChatEngine({ retriever });
-
-// comença a xatejar
-const response = await chatEngine.chat(query);
-```
-
-## Referències de l'API
-
-- [ContextChatEngine (Motor de Xat de Context)](../../api/classes/ContextChatEngine.md)
-- [CondenseQuestionChatEngine (Motor de Xat de Pregunta Condensada)](../../api/classes/ContextChatEngine.md)

apps/docs/i18n/cat/docusaurus-plugin-content-docs/current/modules/high_level/data_index.md

@@ -1,25 +0,0 @@
----
-sidebar_position: 2
----
-
-# Índex
-
-`Aquesta documentació s'ha traduït automàticament i pot contenir errors. No dubteu a obrir una Pull Request per suggerir canvis.`
-
-Un índex és el contenidor bàsic i l'organització de les dades. LlamaIndex.TS suporta dos índexos:
-
-- `VectorStoreIndex` - enviarà els `Node`s més rellevants al LLM quan generi una resposta. El valor per defecte de top-k és 2.
-- `SummaryIndex` - enviarà cada `Node` de l'índex al LLM per generar una resposta.
-
-```typescript
-import { Document, VectorStoreIndex } from "llamaindex";
-
-const document = new Document({ text: "prova" });
-
-const index = await VectorStoreIndex.fromDocuments([document]);
-```
-
-## Referència de l'API
-
-- [SummaryIndex](../../api/classes/SummaryIndex.md)
-- [VectorStoreIndex](../../api/classes/VectorStoreIndex.md)

apps/docs/i18n/cat/docusaurus-plugin-content-docs/current/modules/high_level/data_loader.md

@@ -1,21 +0,0 @@
----
-sidebar_position: 1
----
-
-# Lector / Carregador
-
-`Aquesta documentació s'ha traduït automàticament i pot contenir errors. No dubteu a obrir una Pull Request per suggerir canvis.`
-
-LlamaIndex.TS permet carregar fàcilment fitxers des de carpetes utilitzant la classe `SimpleDirectoryReader`. Actualment, són compatibles els fitxers `.txt`, `.pdf`, `.csv`, `.md` i `.docx`, i s'està planejant afegir-ne més en el futur!
-
-```typescript
-import { SimpleDirectoryReader } from "llamaindex";
-
-documents = new SimpleDirectoryReader().loadData("./data");
-```
-
-## Referència de l'API
-
-- [SimpleDirectoryReader](../../api/classes/SimpleDirectoryReader.md)
-
-"

apps/docs/i18n/cat/docusaurus-plugin-content-docs/current/modules/high_level/documents_and_nodes.md

@@ -1,22 +0,0 @@
----
-sidebar_position: 0
----
-
-# Documents i Nodes
-
-`Aquesta documentació s'ha traduït automàticament i pot contenir errors. No dubteu a obrir una Pull Request per suggerir canvis.`
-
-Els `Document`s i els `Node`s són els blocs de construcció bàsics de qualsevol índex. Tot i que l'API per a aquests objectes és similar, els objectes `Document` representen fitxers sencers, mentre que els `Node`s són peces més petites d'aquest document original, que són adequades per a un LLM i una Q&A.
-
-```typescript
-import { Document } from "llamaindex";
-
-document = new Document({ text: "text", metadata: { key: "val" } });
-```
-
-## Referència de l'API
-
-- [Document](../../api/classes/Document.md)
-- [TextNode](../../api/classes/TextNode.md)
-
-"

apps/docs/i18n/cat/docusaurus-plugin-content-docs/current/modules/high_level/query_engine.md

@@ -1,40 +0,0 @@
----
-sidebar_position: 3
----
-
-# Motor de Consulta (QueryEngine)
-
-`Aquesta documentació s'ha traduït automàticament i pot contenir errors. No dubteu a obrir una Pull Request per suggerir canvis.`
-
-Un motor de consulta envolta un `Retriever` i un `ResponseSynthesizer` en un pipeline, que utilitzarà la cadena de consulta per obtenir nodes i després enviar-los a LLM per generar una resposta.
-
-```typescript
-const queryEngine = index.asQueryEngine();
-const response = await queryEngine.query("cadena de consulta");
-```
-
-## Motor de Consulta de Subpreguntes
-
-El concepte bàsic del Motor de Consulta de Subpreguntes és que divideix una única consulta en múltiples consultes, obté una resposta per a cada una d'aquestes consultes i després combina aquestes respostes diferents en una única resposta coherent per a l'usuari. Podeu pensar-hi com a tècnica de "pensa-ho pas a pas" però iterant sobre les fonts de dades!
-
-### Començar
-
-La manera més senzilla de començar a provar el Motor de Consulta de Subpreguntes és executar el fitxer subquestion.ts a [examples](https://github.com/run-llama/LlamaIndexTS/blob/main/examples/subquestion.ts).
-
-```bash
-npx ts-node subquestion.ts
-```
-
-"
-
-### Eines
-
-El SubQuestionQueryEngine s'implementa amb eines. La idea bàsica de les eines és que són opcions executables per al gran model de llenguatge. En aquest cas, el nostre SubQuestionQueryEngine es basa en QueryEngineTool, que, com podeu imaginar, és una eina per executar consultes en un QueryEngine. Això ens permet donar al model una opció per consultar diferents documents per a diferents preguntes, per exemple. També podeu imaginar que el SubQuestionQueryEngine podria utilitzar una eina que cerqui alguna cosa a la web o obtingui una resposta utilitzant Wolfram Alpha.
-
-Podeu obtenir més informació sobre les eines consultant la documentació de LlamaIndex Python a https://gpt-index.readthedocs.io/en/latest/core_modules/agent_modules/tools/root.html
-
-## Referència de l'API
-
-- [Motor de Consulta del Recuperador (RetrieverQueryEngine)](../../api/classes/RetrieverQueryEngine.md)
-- [Motor de Consulta de Subpreguntes (SubQuestionQueryEngine)](../../api/classes/SubQuestionQueryEngine.md)
-- [Eina del Motor de Consulta (QueryEngineTool)](../../api/interfaces/QueryEngineTool.md)