fix: lint

.eslintrc.cjs

@@ -0,0 +1,84 @@
+const { join } = require("node:path");
+
+module.exports = {
+  root: true,
+  extends: [
+    "turbo",
+    "prettier",
+    "plugin:@typescript-eslint/recommended-type-checked-only",
+  ],
+  parserOptions: {
+    project: join(__dirname, "tsconfig.eslint.json"),
+    __tsconfigRootDir: __dirname,
+  },
+  settings: {
+    react: {
+      version: "999.999.999",
+    },
+  },
+  rules: {
+    "max-params": ["error", 4],
+    "prefer-const": "error",
+    "@typescript-eslint/no-floating-promises": [
+      "error",
+      {
+        ignoreIIFE: true,
+      },
+    ],
+    "no-debugger": "error",
+    "@typescript-eslint/await-thenable": "off",
+    "@typescript-eslint/ban-ts-comment": "off",
+    "@typescript-eslint/ban-types": "off",
+    "no-array-constructor": "off",
+    "@typescript-eslint/no-array-constructor": "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",
+    "@typescript-eslint/no-extra-non-null-assertion": "off",
+    "@typescript-eslint/no-for-in-array": "off",
+    "no-implied-eval": "off",
+    "@typescript-eslint/no-implied-eval": "off",
+    "no-loss-of-precision": "off",
+    "@typescript-eslint/no-loss-of-precision": "off",
+    "@typescript-eslint/no-misused-new": "off",
+    "@typescript-eslint/no-misused-promises": "off",
+    "@typescript-eslint/no-namespace": "off",
+    "@typescript-eslint/no-non-null-asserted-optional-chain": "off",
+    "@typescript-eslint/no-redundant-type-constituents": "off",
+    "@typescript-eslint/no-this-alias": "off",
+    "@typescript-eslint/no-unnecessary-type-assertion": "off",
+    "@typescript-eslint/no-unnecessary-type-constraint": "off",
+    "@typescript-eslint/no-unsafe-argument": "off",
+    "@typescript-eslint/no-unsafe-assignment": "off",
+    "@typescript-eslint/no-unsafe-call": "off",
+    "@typescript-eslint/no-unsafe-declaration-merging": "off",
+    "@typescript-eslint/no-unsafe-enum-comparison": "off",
+    "@typescript-eslint/no-unsafe-member-access": "off",
+    "@typescript-eslint/no-unsafe-return": "off",
+    "no-unused-vars": "off",
+    "@typescript-eslint/no-unused-vars": "off",
+    "@typescript-eslint/no-var-requires": "off",
+    "@typescript-eslint/prefer-as-const": "off",
+    "require-await": "off",
+    "@typescript-eslint/require-await": "off",
+    "@typescript-eslint/restrict-plus-operands": "off",
+    "@typescript-eslint/restrict-template-expressions": "off",
+    "@typescript-eslint/triple-slash-reference": "off",
+    "@typescript-eslint/unbound-method": "off",
+  },
+  overrides: [
+    {
+      files: ["examples/**/*.ts"],
+      rules: {
+        "turbo/no-undeclared-env-vars": "off",
+      },
+    },
+  ],
+  ignorePatterns: ["dist/", "lib/", "deps/"],
+};

.github/workflows/test.yml

@@ -23,7 +23,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        node-version: [18.x, 20.x, 22.x, 23.x]
+        node-version: [18.x, 20.x, 22.x]
     name: E2E on Node.js ${{ matrix.node-version }}
     runs-on: ubuntu-latest
     steps:
@@ -53,7 +53,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        node-version: [18.x, 20.x, 22.x, 23.x]
+        node-version: [18.x, 20.x, 22.x]
     name: Test on Node.js ${{ matrix.node-version }}
     runs-on: ubuntu-latest
     steps:
@@ -84,9 +84,7 @@ jobs:
       - name: Build
         run: pnpm run build
       - name: Use Build For Examples
-        run: |
-          pnpm link ../packages/llamaindex/
-          cd readers && pnpm link ../../packages/llamaindex/
+        run: pnpm link ../packages/llamaindex/
         working-directory: ./examples
       - name: Run Type Check
         run: pnpm run type-check
@@ -119,7 +117,7 @@ jobs:
         run: pnpm run build
       - name: Build ${{ matrix.packages }}
         run: pnpm run build
-        working-directory: e2e/examples/${{ matrix.packages }}
+        working-directory: packages/llamaindex/e2e/examples/${{ matrix.packages }}
 
   typecheck-examples:
     runs-on: ubuntu-latest

.prettierignore

@@ -5,5 +5,3 @@ lib/
 dist/
 .docusaurus/
 .source/
-# prttier doesn't support mdx3 we are using
-*.mdx

CONTRIBUTING.md

@@ -2,58 +2,86 @@
 
 ## Structure
 
-LlamaIndex.TS uses pnpm monorepo.
+This is a monorepo built with Turborepo
 
-We recommend you to understand the basics of Node.js, TypeScript, pnpm, and of course, LLM before contributing.
+Right now, for first-time contributors, these three packages are of the highest importance:
 
-There are some important folders in the repository:
+- `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
 
-- `packages/*`: Contains the source code of the packages. Each package is a separate npm package.
-  - `llamaindex`: The starter package for LlamaIndex.TS, which contains the all sub-packages.
-  - `core`: The core package of LlamaIndex.TS, which contains the abstract classes and interfaces. It is designed for
-    all JS runtime environments.
-  - `env`: The environment package of LlamaIndex.TS, which contains the environment-specific classes and interfaces. It
-    includes compatibility layers for Node.js, Deno, Vercel Edge Runtime, Cloudflare Workers...
-- `apps/*`: The applications based on LlamaIndex.TS.
-  - `next`: Our documentation website based on Next.js.
-- `examples`: The code examples of LlamaIndex.TS using Node.js.
+### Turborepo docs
+
+You can checkout how Turborepo works using the default [README-turborepo.md](/README-turborepo.md)
 
 ## Getting Started
 
-Make sure you have Node.js LIS (Long-term Support) installed. You can check your Node.js version by running:
+Install NodeJS. Preferably v18 using nvm or n.
+
+Inside the LlamaIndexTS directory:
 
-```shell
-node -v
-# v20.x.x
 ```
-
-### Use pnpm
-
-```shell
-corepack enable
-```
-
-### Install dependencies
-
-```shell
+npm i -g pnpm ts-node
 pnpm install
 ```
 
-### Build the packages
+Note: we use pnpm in this repo, which has a lot of the same functionality and CLI options as npm but it does do some things better in a monorepo, like centralizing dependencies and caching.
 
-```shell
-# Build all packages
-turbo build --filter "./packages/*"
+PNPM's has documentation on its [workspace feature](https://pnpm.io/workspaces) and Turborepo had some [useful documentation also](https://turbo.build/repo/docs/core-concepts/monorepos/running-tasks).
+
+### Running Typescript
+
+When we publish to NPM we will have a tsc compiled version of the library in JS. For now, the easiest thing to do is use ts-node.
+
+### Test cases
+
+To run them, run
+
+```
+pnpm run test
+```
+
+To write new test cases write them in [packages/llamaindex/tests](/packages/llamaindex/tests)
+
+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 `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
+
+### Installing packages
+
+To install packages for a specific package or demo application, run
+
+```
+pnpm add [NPM Package] --filter [package or application i.e. llamaindex or docs]
+```
+
+To install packages for every package or application run
+
+```
+pnpm add -w [NPM Package]
 ```
 
 ### Docs
 
-See the [docs](./apps/next/README.md) for more information.
+To contribute to the docs, go to the docs website folder and run the Docusaurus instance.
+
+```bash
+cd apps/docs
+pnpm install
+pnpm start
+```
+
+That should start a webserver which will serve the docs on https://localhost:3000
+
+Any changes you make should be reflected in the browser. If you need to regenerate the API docs and find that your TSDoc isn't getting the updates, feel free to remove apps/docs/api. It will automatically regenerate itself when you run pnpm start again.
 
 ## Changeset
 
-We use [changesets](https://github.com/changesets/changesets) for managing versions and changelogs. To create a new
-changeset, run in the root folder:
+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
@@ -67,6 +95,6 @@ The [Release Github Action](.github/workflows/release.yml) is automatically gene
 PR called "Release {version}".
 
 This PR will update the `package.json` and `CHANGELOG.md` files of each package according to
-the current changesets in the [.changeset](.changeset) folder.
+the current changesets in the [.changeset](.changeset/) folder.
 
 If this PR is merged it will automatically add version tags to the repository and publish the updated packages to NPM.

README.md

@@ -1,16 +1,12 @@
-<p align="center">
-  <img height="100" width="100" alt="LlamaIndex logo" src="https://ts.llamaindex.ai/square.svg" />
-</p>
-<h1 align="center">LlamaIndex.TS</h1>
-<h3 align="center">
-  Data framework for your LLM application.
-</h3>
+# LlamaIndex.TS
 
 [![NPM Version](https://img.shields.io/npm/v/llamaindex)](https://www.npmjs.com/package/llamaindex)
 [![NPM License](https://img.shields.io/npm/l/llamaindex)](https://www.npmjs.com/package/llamaindex)
 [![NPM Downloads](https://img.shields.io/npm/dm/llamaindex)](https://www.npmjs.com/package/llamaindex)
 [![Discord](https://img.shields.io/discord/1059199217496772688)](https://discord.com/invite/eN6D2HQ4aX)
 
+LlamaIndex is a data framework for your LLM application.
+
 Use your own data with large language models (LLMs, OpenAI ChatGPT and others) in JS runtime environments with TypeScript support.
 
 Documentation: https://ts.llamaindex.ai/
@@ -29,7 +25,7 @@ LlamaIndex.TS aims to be a lightweight, easy to use set of libraries to help you
 
 LlamaIndex.TS supports multiple JS environments, including:
 
-- Node.js >= 20 ✅
+- Node.js (18, 20, 22) ✅
 - Deno ✅
 - Bun ✅
 - Nitro ✅
@@ -61,9 +57,213 @@ pnpm install llamaindex
 yarn add llamaindex
 ```
 
-### Setup in Node.js, Deno, Bun, TypeScript...?
+### Setup TypeScript
 
-See our official document: <https://ts.llamaindex.ai/docs/llamaindex/getting_started/>
+```json5
+{
+  compilerOptions: {
+    // ⬇️ add this line to your tsconfig.json
+    moduleResolution: "bundler", // or "node16"
+  },
+}
+```
+
+<details>
+   <summary>Why?</summary>
+  We are shipping both ESM and CJS module, and compatible with Vercel Edge, Cloudflare Workers, and other serverless platforms.
+
+So we are using [conditional exports](https://nodejs.org/api/packages.html#conditional-exports) to support all environments.
+
+This is a kind of modern way of shipping packages, but might cause TypeScript type check to fail because of legacy module resolution.
+
+Imaging you put output file into `/dist/openai.js` but you are importing `llamaindex/openai` in your code, and set `package.json` like this:
+
+```json
+{
+  "exports": {
+    "./openai": "./dist/openai.js"
+  }
+}
+```
+
+In old module resolution, TypeScript will not be able to find the module because it is not follow the file structure, even you run `node index.js` successfully. (on Node.js >=16)
+
+See more about [moduleResolution](https://www.typescriptlang.org/docs/handbook/modules/theory.html#module-resolution) or
+[TypeScript 5.0 blog](https://devblogs.microsoft.com/typescript/announcing-typescript-5-0/#--moduleresolution-bundler7).
+
+</details>
+
+### Node.js
+
+```ts
+import fs from "node:fs/promises";
+import { Document, VectorStoreIndex } from "llamaindex";
+
+async function main() {
+  // Load essay from abramov.txt in Node
+  const essay = await fs.readFile(
+    "node_modules/llamaindex/examples/abramov.txt",
+    "utf-8",
+  );
+
+  // Create Document object with essay
+  const document = new Document({ text: essay });
+
+  // Split text and create embeddings. Store them in a VectorStoreIndex
+  const index = await VectorStoreIndex.fromDocuments([document]);
+
+  // Query the index
+  const queryEngine = index.asQueryEngine();
+  const response = await queryEngine.query({
+    query: "What did the author do in college?",
+  });
+
+  // Output response
+  console.log(response.toString());
+}
+
+main();
+```
+
+```bash
+# `pnpm install tsx` before running the script
+node --import tsx ./main.ts
+```
+
+### Next.js
+
+You will need to add a llamaindex plugin to your Next.js project.
+
+```js
+// next.config.js
+const withLlamaIndex = require("llamaindex/next");
+
+module.exports = withLlamaIndex({
+  // your next.js config
+});
+```
+
+### React Server Actions
+
+You can combine `ai` with `llamaindex` in Next.js, Waku or Redwood.js with RSC (React Server Components).
+
+```tsx
+"use client";
+import { chatWithAgent } from "@/actions";
+import type { JSX } from "react";
+import { useActionState } from "react";
+
+export default function Home() {
+  const [ui, action] = useActionState<JSX.Element | null>(async () => {
+    return chatWithAgent("hello!", []);
+  }, null);
+  return (
+    <main>
+      {ui}
+      <form action={action}>
+        <button>Chat</button>
+      </form>
+    </main>
+  );
+}
+```
+
+```tsx
+// src/actions/index.ts
+"use server";
+import { createStreamableUI } from "ai/rsc";
+import { OpenAIAgent } from "llamaindex";
+import type { ChatMessage } from "llamaindex/llm/types";
+
+export async function chatWithAgent(
+  question: string,
+  prevMessages: ChatMessage[] = [],
+) {
+  const agent = new OpenAIAgent({
+    tools: [
+      // ... adding your tools here
+    ],
+  });
+  const responseStream = await agent.chat(
+    {
+      message: question,
+      chatHistory: prevMessages,
+    },
+    true,
+  );
+  const uiStream = createStreamableUI(<div>loading...</div>);
+  responseStream
+    .pipeTo(
+      new WritableStream({
+        start: () => {
+          uiStream.update("response:");
+        },
+        write: async (message) => {
+          uiStream.append(message.response.delta);
+        },
+      }),
+    )
+    .catch(console.error);
+  return uiStream.value;
+}
+```
+
+### Cloudflare Workers
+
+> [!TIP]
+> Some modules are not supported in Cloudflare Workers which require Node.js APIs.
+
+```ts
+// add `OPENAI_API_KEY` to the `.dev.vars` file
+interface Env {
+  OPENAI_API_KEY: string;
+}
+
+export default {
+  async fetch(
+    request: Request,
+    env: Env,
+    ctx: ExecutionContext,
+  ): Promise<Response> {
+    const { OpenAIAgent, OpenAI } = await import("@llamaindex/openai");
+    const text = await request.text();
+    const agent = new OpenAIAgent({
+      llm: new OpenAI({
+        apiKey: env.OPENAI_API_KEY,
+      }),
+      tools: [],
+    });
+    const responseStream = await agent.chat({
+      stream: true,
+      message: text,
+    });
+    const textEncoder = new TextEncoder();
+    const response = responseStream.pipeThrough<Uint8Array>(
+      new TransformStream({
+        transform: (chunk, controller) => {
+          controller.enqueue(textEncoder.encode(chunk.delta));
+        },
+      }),
+    );
+    return new Response(response);
+  },
+};
+```
+
+### Vite
+
+We have some wasm dependencies for better performance. You can use `vite-plugin-wasm` to load them.
+
+```ts
+import wasm from "vite-plugin-wasm";
+
+export default {
+  plugins: [wasm()],
+  ssr: {
+    external: ["tiktoken"],
+  },
+};
+```
 
 ### Tips when using in non-Node.js environments
 

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

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

apps/docs/.gitignore

@@ -0,0 +1,21 @@
+# Dependencies
+/node_modules
+
+# Production
+/build
+
+# Generated files
+.docusaurus
+.cache-loader
+lib
+
+# Misc
+.DS_Store
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*

apps/docs/README-docusaurus.md

@@ -0,0 +1,47 @@
+# Website
+
+This website is built using [Docusaurus 2](https://docusaurus.io/), a modern static website generator.
+
+### Installation
+
+```
+$ pnpm
+```
+
+### Local Development
+
+```
+$ pnpm start
+```
+
+This command starts a local development server and opens up a browser window. Most changes are reflected live without having to restart the server.
+
+However, the searchbar may not function with `yarn start`. Instead, run `yarn build` and launch a server:
+
+```
+$ npx http-server ./build
+```
+
+### Build
+
+```
+$ pnpm build
+```
+
+This command generates static content into the `build` directory and can be served using any static contents hosting service.
+
+### Deployment
+
+Using SSH:
+
+```
+$ USE_SSH=true pnpm deploy
+```
+
+Not using SSH:
+
+```
+$ GIT_USER=<Your GitHub username> pnpm deploy
+```
+
+If you are using GitHub pages for hosting, this command is a convenient way to build the website and push to the `gh-pages` branch.

apps/docs/babel.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+  presets: [require.resolve("@docusaurus/core/lib/babel/preset")],
+};

apps/docs/blog/2024-04-26-v0.3.0.md

@@ -0,0 +1,493 @@
+---
+title: LlamaIndexTS v0.3.0
+description: This is my first post on Docusaurus.
+slug: welcome-llamaindexts-v0.3
+authors:
+  - name: Alex Yang
+    title: LlamaIndexTS maintainer, Node.js Member
+    url: https://github.com/himself65
+    image_url: https://github.com/himself65.png
+tags: [llamaindex, agent]
+hide_table_of_contents: false
+---
+
+- [What's new in LlamaIndexTS v0.3.0](#whats-new-in-llamaindexts-v030)
+- [Improvement in LlamaIndexTS v0.3.0](#improvement-in-llamaindexts-v030)
+- [What's the next?](#whats-the-next)
+
+## What's new in LlamaIndexTS v0.3.0
+
+## Agents
+
+In this release, we've not only ported the Agent module from the LlamaIndex Python version but have significantly
+enhanced it to be more powerful and user-friendly for JavaScript/TypeScript applications.
+
+Starting from v0.3.0, we are introducing multiple agents specifically designed for RAG applications, including:
+
+- `OpenAIAgent`
+- `AnthropicAgent`
+- `ReActAgent`:
+
+```ts
+import { OpenAIAgent } from "llamaindex";
+import { tools } from "./tools";
+
+const agent = new OpenAIAgent({
+  tools: [...tools],
+});
+const { response } = await agent.chat({
+  message: "What is weather today?",
+  stream: false,
+});
+
+console.log(response.message.content);
+```
+
+We are also introducing the abstract AgentRunner class, which allows you to create your own agent by simply implementing
+the task handler.
+
+```ts
+import { AgentRunner, OpenAI } from "llamaindex";
+
+class MyLLM extends OpenAI {}
+
+export class MyAgentWorker extends AgentWorker<MyLLM> {
+  taskHandler = MyAgent.taskHandler;
+}
+
+export class MyAgent extends AgentRunner<MyLLM> {
+  constructor(params: Params) {
+    super({
+      llm: params.llm,
+      chatHistory: params.chatHistory ?? [],
+      systemPrompt: params.systemPrompt ?? null,
+      runner: new MyAgentWorker(),
+      tools:
+        "tools" in params
+          ? params.tools
+          : params.toolRetriever.retrieve.bind(params.toolRetriever),
+    });
+  }
+
+  // create store is a function to create a store for each task, by default it only includes `messages` and `toolOutputs`
+  createStore = AgentRunner.defaultCreateStore;
+
+  static taskHandler: TaskHandler<Anthropic> = async (step, enqueueOutput) => {
+    const { llm, stream } = step.context;
+    // initialize the input
+    const response = await llm.chat({
+      stream,
+      messages: step.context.store.messages,
+    });
+    // store the response for next task step
+    step.context.store.messages = [
+      ...step.context.store.messages,
+      response.message,
+    ];
+    // your logic here to decide whether to continue the task
+    const shouldContinue = Math.random(); /* <-- replace with your logic here */
+    enqueueOutput({
+      taskStep: step,
+      output: response,
+      isLast: !shouldContinue,
+    });
+    if (shouldContinue) {
+      const content = await someHeavyFunctionCall();
+      // if you want to continue the task, you can insert your new context for the next task step
+      step.context.store.messages = [
+        ...step.context.store.messages,
+        {
+          content,
+          role: "user",
+        },
+      ];
+    }
+  };
+}
+```
+
+### Web Stream API for Streaming response
+
+Web Stream is a web standard utilized in many modern web frameworks and libraries (like React 19, Deno, Node 22). We
+have migrated streaming responses to Web Stream to ensure broader compatibility.
+
+For instance, you can use the streaming response in a simple HTTP Server:
+
+```ts
+import { createServer } from "http";
+import { OpenAIAgent } from "llamaindex";
+import { OpenAIStream, streamToResponse } from "ai";
+import { tools } from "./tools";
+
+const agent = new OpenAIAgent({
+  tools: [...tools],
+});
+
+const server = createServer(async (req, res) => {
+  const response = await agent.chat({
+    message: "What is weather today?",
+    stream: true,
+  });
+
+  // Transform the response into a string readable stream
+  const stream: ReadableStream<string> = response.pipeThrough(
+    new TransformStream({
+      transform: (chunk, controller) => {
+        controller.enqueue(chunk.response.delta);
+      },
+    }),
+  );
+
+  // Pipe the stream to the response
+  streamToResponse(stream, res);
+});
+
+server.listen(3000);
+```
+
+Or it can be integrated into React Server Components (RSC) in Next.js:
+
+```tsx
+// app/actions/index.tsx
+"use server";
+import { createStreamableUI } from "ai/rsc";
+import { OpenAIAgent } from "llamaindex";
+import type { ChatMessage } from "llamaindex/llm/types";
+
+export async function chatWithAgent(
+  question: string,
+  prevMessages: ChatMessage[] = [],
+) {
+  const agent = new OpenAIAgent({
+    tools: [],
+  });
+  const responseStream = await agent.chat({
+    stream: true,
+    message: question,
+    chatHistory: prevMessages,
+  });
+  const uiStream = createStreamableUI(<div>loading...</div>);
+  responseStream
+    .pipeTo(
+      new WritableStream({
+        start: () => {
+          uiStream.update("response:");
+        },
+        write: async (message) => {
+          uiStream.append(message.response.delta);
+        },
+      }),
+    )
+    .catch(uiStream.error);
+  return uiStream.value;
+}
+```
+
+```tsx
+// app/src/page.tsx
+"use client";
+import { chatWithAgent } from "@/actions";
+import type { JSX } from "react";
+import { useFormState } from "react-dom";
+
+export const runtime = "edge";
+
+export default function Home() {
+  const [state, action] = useFormState<JSX.Element | null>(async () => {
+    return chatWithAgent("hello!", []);
+  }, null);
+  return (
+    <main>
+      {state}
+      <form action={action}>
+        <button>Chat</button>
+      </form>
+    </main>
+  );
+}
+```
+
+## Improvement in LlamaIndexTS v0.3.0
+
+### Better TypeScript support
+
+We have made significant improvements to the type system to ensure that all code is thoroughly checked before it is
+published. This ongoing enhancement has already resulted in better module reliability and developer experience.
+
+For example, we have improved `FunctionTool` type with generic support:
+
+```ts
+type Input = {
+  a: number;
+  b: number;
+};
+
+const sumNumbers = FunctionTool.from<Input>(
+  ({ a, b }) => `${a + b}`, // a and b will be checked as number
+  // JSON schema will be an error if you type wrong.
+  {
+    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"],
+    },
+  },
+);
+```
+
+![type checking](./img/function_tool_example.png)
+
+### Better Next.js, Deno, Cloudflare Worker, and Waku(Vite) support
+
+In addition to Node.js, LlamaIndexTS now offers enhanced support for Next.js, Deno, and Cloudflare Workers, making it
+more versatile across different platforms.
+
+For now, you can install llamaindex and directly import it into your existing Next.js, Deno or Cloudflare Worker project
+**without any extra configuration**.
+
+#### [Deno](https://deno.com/)
+
+You can use LlamaIndexTS in Deno by installation through JSR:
+
+```sh
+jsr add @llamaindex/core
+```
+
+#### [Cloudflare Worker](https://developers.cloudflare.com/workers/)
+
+For Cloudflare Workers, here is a starter template:
+
+```typescript
+export default {
+  async fetch(
+    request: Request,
+    env: Env,
+    ctx: ExecutionContext,
+  ): Promise<Response> {
+    const { setEnvs } = await import("@llamaindex/env");
+    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);
+  },
+};
+```
+
+### [Waku (Vite)](https://waku.gg/)
+
+Waku powered by Vite is a minimal React framework that supports multiple JS environments, including Deno, Cloudflare, and
+Node.js.
+
+You can use LlamaIndexTS with Node.js output to enable full Node.js support with React.
+
+```sh
+npm install llamaindex
+```
+
+```ts
+// file: src/actions.ts
+"use server";
+import { Document, VectorStoreIndex } from "llamaindex";
+import { readFile } from "node:fs/promises";
+
+const path = "node_modules/llamaindex/examples/abramov.txt";
+
+const essay = await readFile(path, "utf-8");
+
+// Create Document object with essay
+const document = new Document({ text: essay, id_: path });
+
+// Split text and create embeddings. Store them in a VectorStoreIndex
+const index = await VectorStoreIndex.fromDocuments([document]);
+
+const queryEngine = index.asQueryEngine();
+
+export async function chatWithAI(question: string): Promise<string> {
+  const { response } = await queryEngine.query({ query: question });
+  return response;
+}
+```
+
+```tsx
+// file: src/pages/index.tsx
+import { chatWithAI } from "./actions";
+
+export default async function HomePage() {
+  return (
+    <div>
+      <Chat askQuestion={chatWithAI} />
+    </div>
+  );
+}
+```
+
+```tsx
+// file: src/components/Chat.tsx
+"use client";
+
+export type ChatProps = {
+  askQuestion: (question: string) => Promise<string>;
+};
+
+export const Chat = (props: ChatProps) => {
+  const [response, setResponse] = useState<string | null>(null);
+
+  return (
+    <section className="border-blue-400 -mx-4 mt-4 rounded border border-dashed p-4">
+      <h2 className="text-lg font-bold">Chat with AI</h2>
+      {response ? (
+        <p className="text-sm text-gray-600 max-w-sm">{response}</p>
+      ) : null}
+      <form
+        action={async (formData) => {
+          const question = formData.get("question") as string | null;
+          if (question) {
+            setResponse(await props.askQuestion(question));
+          }
+        }}
+      >
+        <input
+          type="text"
+          name="question"
+          className="border border-gray-400 rounded-sm px-2 py-0.5 text-sm"
+        />
+        <button className="rounded-sm bg-black px-2 py-0.5 text-sm text-white">
+          Ask
+        </button>
+      </form>
+    </section>
+  );
+};
+```
+
+```shell
+waku dev # development mode
+waku build # build for production
+waku start # start the production server
+```
+
+Note that not all the modules are supported in all JS environments because of
+lack of the file system, network API,
+and incompatibility with the Node.js API by upstream dependencies.
+
+But we are trying to make it more compatible with all the environments.
+
+## What's the next?
+
+As we continue to develop LlamaIndexTS, our focus remains on providing more comprehensive and powerful tools for
+creating custom agents.
+
+### Align with the Python `llama-index`
+
+We aim to align LlamaIndexTS with the Python version to ensure API consistency and ease of use for developers familiar
+with the Python ecosystem.
+
+### Align with the Web Standard and JS development
+
+Not all python APIs are compatible and easy to use in JavaScript/TypeScript.
+We are trying to make the API more compatible with the Web Standard and JavaScript modern development.
+
+### More Agents
+
+Future releases will introduce more agents from the Python Llama-Index and explore APIs tailored to real-world use
+cases.
+
+### 🧪 `@llamaindex/tool`
+
+We are exploring innovative ways to create tools for agents. The `@llamaindex/tool` library allows you to transform any
+function into a tool for an agent, simplifying the development process and reducing runtime costs.
+
+```ts
+export function getWeather(city: string) {
+  return `The weather in ${city} is sunny.`;
+}
+
+// you don't need to worry about the shcema with different llm tools
+export function getTemperature(city: string) {
+  return `The temperature in ${city} is 25°C.`;
+}
+
+export function getCurrentCity() {
+  return "New York";
+}
+```
+
+These functions can be easily integrated into your applications, such as Next.js:
+
+```ts
+"use server";
+import { OpenAI } from "openai";
+import { getTools } from "@llamaindex/tool";
+
+export async function chat(message: string) {
+  const openai = new OpenAI();
+  openai.chat.completions.create({
+    messages: [
+      {
+        role: "user",
+        content: "What is the weather in the current city?",
+      },
+    ],
+    tools: getTools("openai"),
+  });
+}
+```
+
+```ts
+// next.config.js
+const withTool = require("@llamaindex/tool/next");
+
+const config = {
+  // Your original Next.js config
+};
+module.exports = withTool(config);
+```
+
+The functions are automatically transformed into tools for the agent at compile time, which eliminates any extra runtime
+costs. This feature is particularly beneficial when you need to debug or deploy your assistant.
+
+For deploying your local functions into OpenAI, you can use a simple command:
+
+```sh
+npm install -g @llamaindex/tool
+mkai --tools ./src/index.llama.ts
+# Successfully created assistant: asst_XXX
+# chat with your assistant by `chatai --assistant asst_XXX`
+chatai --assistant asst_XXX
+# Open your browser and chat with your assistant
+# Running at http://localhost:3000
+```
+
+This deployment process simplifies the testing and implementation of your custom tools in a live environment.
+
+As this project is still in its early stages, we continue to explore the best ways to create and integrate tools for
+agents. For more information and updates, visit the @llamaindex/tool repository.
+
+This release of LlamaIndexTS v0.3.0 marks a significant step forward in our journey to provide developers with robust,
+flexible tools for building advanced agents. We are excited to see how our community utilizes these new capabilities to
+create innovative solutions and look forward to continuing to support and enhance LlamaIndexTS in future updates.

apps/docs/docs/.gitignore

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

apps/docs/docs/examples/_category_.yml

@@ -0,0 +1,2 @@
+label: Examples
+position: 3

apps/docs/docs/examples/agent.mdx

@@ -0,0 +1,10 @@
+# Agents
+
+A built-in agent that can take decisions and reasoning based on the tools provided to it.
+
+## OpenAI Agent
+
+import CodeBlock from "@theme/CodeBlock";
+import CodeSource from "!raw-loader!../../../../examples/agent/openai";
+
+<CodeBlock language="ts">{CodeSource}</CodeBlock>

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/examples/chat_engine.mdx

@@ -0,0 +1,12 @@
+---
+sidebar_position: 2
+---
+
+import CodeBlock from "@theme/CodeBlock";
+import CodeSource from "!raw-loader!../../../../examples/chatEngine";
+
+# Chat Engine
+
+Chat Engine is a class that allows you to create a chatbot from a retriever. It is a wrapper around a retriever that allows you to chat with it in a conversational manner.
+
+<CodeBlock language="ts">{CodeSource}</CodeBlock>

apps/docs/docs/examples/local_llm.mdx

@@ -1,6 +1,4 @@
----
-title: Local LLMs
----
+# Local LLMs
 
 LlamaIndex.TS supports OpenAI and [other remote LLM APIs](other_llms). You can also run a local LLM on your machine!
 

apps/docs/docs/examples/more_examples.mdx

@@ -1,7 +1,9 @@
 ---
-title: See all examples
+sidebar_position: 1
 ---
 
+# See all examples
+
 Our GitHub repository has a wealth of examples to explore and try out. You can check out our [examples folder](https://github.com/run-llama/LlamaIndexTS/tree/main/examples) to see them all at once, or browse the pages in this section for some selected highlights.
 
 ## Check out all examples

apps/docs/docs/examples/other_llms.mdx

@@ -1,9 +1,7 @@
----
-title: Using other LLM APIs
----
+import CodeBlock from "@theme/CodeBlock";
+import CodeSource from "!raw-loader!../../../../examples/mistral";
 
-import { DynamicCodeBlock } from 'fumadocs-ui/components/dynamic-codeblock';
-import CodeSource from "!raw-loader!../../../../../../../examples/mistral";
+# Using other LLM APIs
 
 By default LlamaIndex.TS uses OpenAI's LLMs and embedding models, but we support [lots of other LLMs](../modules/llms) including models from Mistral (Mistral, Mixtral), Anthropic (Claude) and Google (Gemini).
 
@@ -40,4 +38,4 @@ We support [many different embeddings](../modules/embeddings).
 
 This example uses Mistral's `mistral-tiny` model as the LLM and Mistral for embeddings as well.
 
-<DynamicCodeBlock lang="ts" code={CodeSource} />
+<CodeBlock language="ts">{CodeSource}</CodeBlock>

apps/docs/docs/examples/save_load_index.mdx

@@ -0,0 +1,10 @@
+---
+sidebar_position: 4
+---
+
+import CodeBlock from "@theme/CodeBlock";
+import CodeSource from "!raw-loader!../../../../examples/storageContext";
+
+# Save/Load an Index
+
+<CodeBlock language="ts">{CodeSource}</CodeBlock>

apps/docs/docs/examples/summary_index.mdx

@@ -0,0 +1,10 @@
+---
+sidebar_position: 3
+---
+
+import CodeBlock from "@theme/CodeBlock";
+import CodeSource from "!raw-loader!../../../../examples/summaryIndex";
+
+# Summary Index
+
+<CodeBlock language="ts">{CodeSource}</CodeBlock>

apps/docs/docs/examples/vector_index.mdx

@@ -0,0 +1,10 @@
+---
+sidebar_position: 2
+---
+
+import CodeBlock from "@theme/CodeBlock";
+import CodeSource from "!raw-loader!../../../../examples/vectorIndex";
+
+# Vector Index
+
+<CodeBlock language="ts">{CodeSource}</CodeBlock>

apps/docs/docs/getting_started/_category_.yml

@@ -0,0 +1,2 @@
+label: Getting Started
+position: 1

apps/docs/docs/getting_started/concepts.md

@@ -1,7 +1,9 @@
 ---
-title: Concepts
+sidebar_position: 3
 ---
 
+# Concepts
+
 LlamaIndex.TS helps you build LLM-powered applications (e.g. Q&A, chatbot) over custom data.
 
 In this high-level concepts guide, you will learn:
@@ -30,12 +32,12 @@ LlamaIndex.TS help you prepare the knowledge base with a suite of data connector
 
 ![](../_static/concepts/indexing.jpg)
 
-[**Data Loaders**](/docs/llamaindex/modules/data_loaders/index):
+[**Data Loaders**](../modules/data_loaders/index.mdx):
 A data connector (i.e. `Reader`) ingest data from different data sources and data formats into a simple `Document` representation (text and simple metadata).
 
-[**Documents / Nodes**](/docs/llamaindex/modules/documents_and_nodes/index): A `Document` is a generic container around any data source - for instance, a PDF, an API output, or retrieved data from a database. A `Node` is the atomic unit of data in LlamaIndex and represents a "chunk" of a source `Document`. It's a rich representation that includes metadata and relationships (to other nodes) to enable accurate and expressive retrieval operations.
+[**Documents / Nodes**](../modules/documents_and_nodes/index.md): A `Document` is a generic container around any data source - for instance, a PDF, an API output, or retrieved data from a database. A `Node` is the atomic unit of data in LlamaIndex and represents a "chunk" of a source `Document`. It's a rich representation that includes metadata and relationships (to other nodes) to enable accurate and expressive retrieval operations.
 
-[**Data Indexes**](/docs/llamaindex/modules/data_index):
+[**Data Indexes**](../modules/data_index.md):
 Once you've ingested your data, LlamaIndex helps you index data into a format that's easy to retrieve.
 
 Under the hood, LlamaIndex parses the raw documents into intermediate representations, calculates vector embeddings, and stores your data in-memory or to disk.
@@ -58,19 +60,19 @@ These building blocks can be customized to reflect ranking preferences, as well
 
 #### Building Blocks
 
-[**Retrievers**](/docs/llamaindex/modules/retriever):
+[**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 different indices, the most popular being dense retrieval against a vector index.
 
-[**Response Synthesizers**](/docs/llamaindex/modules/response_synthesizer):
+[**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.
 
 #### Pipelines
 
-[**Query Engines**](/docs/llamaindex/modules/query_engines):
+[**Query Engines**](../modules/query_engines):
 A query engine is an end-to-end pipeline that allow you to ask question over your data.
 It takes in a natural language query, and returns a response, along with reference context retrieved and passed to the LLM.
 
-[**Chat Engines**](/docs/llamaindex/modules/chat_engine):
+[**Chat Engines**](../modules/chat_engine.md):
 A chat engine is an end-to-end pipeline for having a conversation with your data
 (multiple back-and-forth instead of a single question & answer).

apps/docs/docs/getting_started/environments.md

@@ -0,0 +1,22 @@
+---
+sidebar_position: 2
+---
+
+# Environments
+
+We support Node.JS versions 18, 20 and 22, with experimental support for Deno, Bun and Vercel Edge functions.
+
+## NextJS
+
+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
+// 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/getting_started/installation.mdx

@@ -0,0 +1,34 @@
+---
+sidebar_position: 0
+---
+
+# Installation and Setup
+
+We support Node.JS versions 18, 20 and 22, with experimental support for Deno, Bun and Vercel Edge functions.
+
+## Installation from NPM
+
+```bash npm2yarn
+npm install llamaindex
+```
+
+### Environment variables
+
+Our examples use OpenAI by default. You can use [other LLMs](../examples/other_llms) via their APIs; if you would prefer to use local models check out our [local LLM example](../examples/local_llm).
+
+To use OpenAI, you'll need to [get an OpenAI API key](https://platform.openai.com/account/api-keys) and then make it available as an environment variable this way:
+
+```bash
+export OPENAI_API_KEY="sk-......" # Replace with your key
+```
+
+If you want to have it automatically loaded every time, add it to your `.zshrc/.bashrc`.
+
+**WARNING:** do not check in your OpenAI key into version control. GitHub automatically invalidates OpenAI keys checked in by accident.
+
+## What next?
+
+- The easiest way to started is to [build a full-stack chat app with `create-llama`](starter_tutorial/chatbot).
+- Try our other [getting started tutorials](starter_tutorial/retrieval_augmented_generation)
+- Learn more about the [high level concepts](concepts) behind how LlamaIndex works
+- Check out our [many examples](../examples/more_examples) of LlamaIndex.TS in action

apps/docs/docs/getting_started/starter_tutorial/_category_.yml

@@ -0,0 +1,2 @@
+label: Starter Tutorials
+position: 1

apps/docs/docs/getting_started/starter_tutorial/agent.mdx

@@ -1,9 +1,11 @@
 ---
-title: Agent tutorial
+sidebar_position: 4
 ---
 
-import { DynamicCodeBlock } from 'fumadocs-ui/components/dynamic-codeblock';
-import CodeSource from "!raw-loader!../../../../../../../../examples/agent/openai";
+import CodeBlock from "@theme/CodeBlock";
+import CodeSource from "!raw-loader!../../../../../examples/agent/openai";
+
+# Agent tutorial
 
 We have a comprehensive, step-by-step [guide to building agents in LlamaIndex.TS](../../guides/agents/setup) that we recommend to learn what agents are and how to build them for production. But building a basic agent is simple:
 
@@ -27,7 +29,7 @@ Create the file `example.ts`. This code will:
 - Give an example of the data structure we wish to generate
 - Prompt the LLM with instructions and the example, plus a sample transcript
 
-<DynamicCodeBlock lang="ts" code={CodeSource} />
+<CodeBlock language="ts">{CodeSource}</CodeBlock>
 
 To run the code:
 

apps/docs/docs/getting_started/starter_tutorial/chatbot.mdx

@@ -1,7 +1,9 @@
 ---
-title: Chatbot tutorial
+sidebar_position: 2
 ---
 
+# Chatbot tutorial
+
 Once you've mastered basic [retrieval-augment generation](retrieval_augmented_generation) you may want to create an interface to chat with your data. You can do this step-by-step, but we recommend getting started quickly using `create-llama`.
 
 ## Using create-llama

apps/docs/docs/getting_started/starter_tutorial/retrieval_augmented_generation.mdx

@@ -1,10 +1,12 @@
 ---
-title: Retrieval Augmented Generation (RAG) Tutorial
+sidebar_position: 1
 ---
 
-import { DynamicCodeBlock } from 'fumadocs-ui/components/dynamic-codeblock';
-import CodeSource from "!raw-loader!../../../../../../../../examples/vectorIndex";
-import TSConfigSource from "!!raw-loader!../../../../../../../../examples/tsconfig.json";
+import CodeBlock from "@theme/CodeBlock";
+import CodeSource from "!raw-loader!../../../../../examples/vectorIndex";
+import TSConfigSource from "!!raw-loader!../../../../../examples/tsconfig.json";
+
+# Retrieval Augmented Generation (RAG) Tutorial
 
 One of the most common use-cases for LlamaIndex is Retrieval-Augmented Generation or RAG, in which your data is indexed and selectively retrieved to be given to an LLM as source material for responding to a query. You can learn more about the [concepts behind RAG](../concepts).
 
@@ -17,7 +19,7 @@ npm init
 npm install -D typescript @types/node
 ```
 
-Then, check out the [installation](../setup) steps to install LlamaIndex.TS and prepare an OpenAI key.
+Then, check out the [installation](../installation) steps to install LlamaIndex.TS and prepare an OpenAI key.
 
 You can use [other LLMs](../../examples/other_llms) via their APIs; if you would prefer to use local models check out our [local LLM example](../../examples/local_llm).
 
@@ -30,11 +32,11 @@ Create the file `example.ts`. This code will
 - index it (which creates embeddings using OpenAI)
 - create a query engine to answer questions about the data
 
-<DynamicCodeBlock lang="ts" code={CodeSource} />
+<CodeBlock language="ts">{CodeSource}</CodeBlock>
 
 Create a `tsconfig.json` file in the same folder:
 
-<DynamicCodeBlock lang="json" code={TSConfigSource} />
+<CodeBlock language="json">{TSConfigSource}</CodeBlock>
 
 Now you can run the code with
 

apps/docs/docs/getting_started/starter_tutorial/structured_data_extraction.mdx

@@ -1,11 +1,13 @@
 ---
-title: Structured data extraction tutorial
+sidebar_position: 3
 ---
 
-import { DynamicCodeBlock } from 'fumadocs-ui/components/dynamic-codeblock';
-import CodeSource from "!raw-loader!../../../../../../../../examples/jsonExtract";
+import CodeBlock from "@theme/CodeBlock";
+import CodeSource from "!raw-loader!../../../../../examples/jsonExtract";
 
-Make sure you have installed LlamaIndex.TS and have an OpenAI key. If you haven't, check out the [installation](../setup) guide.
+# Structured data extraction tutorial
+
+Make sure you have installed LlamaIndex.TS and have an OpenAI key. If you haven't, check out the [installation](../installation) guide.
 
 You can use [other LLMs](../../examples/other_llms) via their APIs; if you would prefer to use local models check out our [local LLM example](../../examples/local_llm).
 
@@ -26,7 +28,7 @@ Create the file `example.ts`. This code will:
 - Give an example of the data structure we wish to generate
 - Prompt the LLM with instructions and the example, plus a sample transcript
 
-<DynamicCodeBlock lang="ts" code={CodeSource} />
+<CodeBlock language="ts">{CodeSource}</CodeBlock>
 
 To run the code:
 

apps/docs/docs/guides/_category_.yml

@@ -0,0 +1,2 @@
+label: Guides
+position: 2

apps/docs/docs/guides/agents/1_setup.mdx

@@ -1,7 +1,9 @@
 ---
-title: Agent tutorial
+sidebar_position: 1
 ---
 
+# Getting started
+
 In this guide we'll walk you through the process of building an Agent in JavaScript using the LlamaIndex.TS library, starting from nothing and adding complexity in stages.
 
 ## What is an Agent?

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

@@ -1,6 +1,4 @@
----
-title: Create a basic agent
----
+# Create a basic agent
 
 We want to use `await` so we're going to wrap all of our code in a `main` function, like this:
 

apps/docs/docs/guides/agents/3_local_model.mdx

@@ -1,6 +1,4 @@
----
-title: Using a local model via Ollama
----
+# Using a local model via Ollama
 
 If you're happy using OpenAI, you can skip this section, but many people are interested in using models they run themselves. The easiest way to do this is via the great work of our friends at [Ollama](https://ollama.com/), who provide a simple to use client that will download, install and run a [growing range of models](https://ollama.com/library) for you.
 

apps/docs/docs/guides/agents/4_agentic_rag.mdx

@@ -1,28 +1,25 @@
----
-title: Adding Retrieval-Augmented Generation (RAG)
----
+# Adding Retrieval-Augmented Generation (RAG)
 
 While an agent that can perform math is nifty (LLMs are usually not very good at math), LLM-based applications are always more interesting when they work with large amounts of data. In this case, we're going to use a 200-page PDF of the proposed budget of the city of San Francisco for fiscal years 2024-2024 and 2024-2025. It's a great example because it's extremely wordy and full of tables of figures, which present a challenge for humans and LLMs alike.
 
 To learn more about RAG, we recommend this [introduction](https://docs.llamaindex.ai/en/stable/getting_started/concepts/) from our Python docs. We'll assume you know the basics:
 
-- Parse your source data into chunks of text.
-- Encode that text as numbers, called embeddings.
-- Search your embeddings for the most relevant chunks of text.
-- Use the relevant chunks along with a query to ask an LLM to generate an answer.
+- You need to parse your source data into chunks of text
+- You need to encode that text as numbers, called embeddings
+- You need to search your embeddings for the most relevant chunks of text
+- You feed your relevant chunks and a query to an LLM to answer a question
 
 We're going to start with the same agent we [built in step 1](https://github.com/run-llama/ts-agents/blob/main/1_agent/agent.ts), but make a few changes. You can find the finished version [in the repository](https://github.com/run-llama/ts-agents/blob/main/2_agentic_rag/agent.ts).
 
 ### New dependencies
 
-We'll be bringing in `SimpleDirectoryReader`, `HuggingFaceEmbedding`, `VectorStoreIndex`, and `QueryEngineTool`, `OpenAIContextAwareAgent` from LlamaIndex.TS, as well as the dependencies we previously used.
+We'll be bringing in `SimpleDirectoryReader`, `HuggingFaceEmbedding`, `VectorStoreIndex`, and `QueryEngineTool` from LlamaIndex.TS, as well as the dependencies we previously used.
 
 ```javascript
 import {
   OpenAI,
   FunctionTool,
   OpenAIAgent,
-  OpenAIContextAwareAgent,
   Settings,
   SimpleDirectoryReader,
   HuggingFaceEmbedding,
@@ -44,7 +41,7 @@ Settings.embedModel = new HuggingFaceEmbedding({
 
 ### Load data using SimpleDirectoryReader
 
-`SimpleDirectoryReader` is a flexible tool that can read various file formats. We will point it at our data directory, which contains a single PDF file, and retrieve a set of documents.
+SimpleDirectoryReader is a flexible tool that can read a variety of file formats. We're going to point it at our data directory, which contains just the single PDF file, and get it to return a set of documents.
 
 ```javascript
 const reader = new SimpleDirectoryReader();
@@ -53,7 +50,7 @@ const documents = await reader.loadData("../data");
 
 ### Index our data
 
-We will convert our text into embeddings using the `VectorStoreIndex` class through the `fromDocuments` method, which utilizes the embedding model defined earlier in `Settings`.
+Now we turn our text into embeddings. The `VectorStoreIndex` class takes care of this for us when we use the `fromDocuments` method (it uses the embedding model we defined in `Settings` earlier).
 
 ```javascript
 const index = await VectorStoreIndex.fromDocuments(documents);
@@ -75,35 +72,21 @@ By default LlamaIndex will retrieve just the 2 most relevant chunks of text. Thi
 retriever.similarityTopK = 10;
 ```
 
-### Approach 1: Create a Context-Aware Agent
+### Create a query engine
 
-With the retriever ready, you can create a **context-aware agent**.
+And our final step in creating a RAG pipeline is to create a query engine that will use the retriever to find the most relevant chunks of text, and then use the LLM to answer the question.
 
 ```javascript
-const agent = new OpenAIContextAwareAgent({
-  contextRetriever: retriever,
+const queryEngine = await index.asQueryEngine({
+  retriever,
 });
-
-// Example query to the context-aware agent
-let response = await agent.chat({
-  message: `What's the budget of San Francisco in 2023-2024?`,
-});
-
-console.log(response);
 ```
 
-**Expected Output:**
+### Define the query engine as a tool
 
-```md
-The total budget for the City and County of San Francisco for the fiscal year 2023-2024 is $14.6 billion. This represents a $611.8 million, or 4.4 percent, increase over the previous fiscal year's budget. The budget covers various expenditures across different departments and services, including significant allocations to public works, transportation, commerce, public protection, and health services.
-```
-
-### Approach 2: Using QueryEngineTool (Alternative Approach)
-
-If you prefer more flexibility and don't mind additional complexity, you can create a `QueryEngineTool`. This approach allows you to define the query logic, providing a more tailored way to interact with the data, but note that it introduces a delay due to the extra tool call.
+Just as before we created a `FunctionTool`, we're going to create a `QueryEngineTool` that uses our `queryEngine`.
 
 ```javascript
-const queryEngine = await index.asQueryEngine({ retriever });
 const tools = [
   new QueryEngineTool({
     queryEngine: queryEngine,
@@ -113,18 +96,28 @@ const tools = [
     },
   }),
 ];
+```
 
-// Create an agent using the tools array
+As before, we've created an array of tools with just one tool in it. The metadata is slightly different: we don't need to define our parameters, we just give the tool a name and a natural-language description.
+
+### Create the agent as before
+
+Creating the agent and asking a question is exactly the same as before, but we'll ask a different question.
+
+```javascript
+// create the agent
 const agent = new OpenAIAgent({ tools });
 
-let toolResponse = await agent.chat({
+let response = await agent.chat({
   message: "What's the budget of San Francisco in 2023-2024?",
 });
 
-console.log(toolResponse);
+console.log(response);
 ```
 
-**Expected Output:**
+Once again we'll run `npx tsx agent.ts` and see what we get:
+
+**_Output_**
 
 ```javascript
 {
@@ -145,12 +138,28 @@ console.log(toolResponse);
 }
 ```
 
+```javascript
+{
+  response: {
+    raw: {
+      id: 'chatcmpl-9KxUkwizVCYCmxwFQcZFSHrInzNFU',
+      object: 'chat.completion',
+      created: 1714782286,
+      model: 'gpt-4-turbo-2024-04-09',
+      choices: [Array],
+      usage: [Object],
+      system_fingerprint: 'fp_ea6eb70039'
+    },
+    message: {
+      content: "The total budget for the City and County of San Francisco for the fiscal year 2023-2024 is $14.6 billion. This represents a $611.8 million, or 4.4 percent, increase over the previous fiscal year's budget. The budget covers various expenditures across different departments and services, including significant allocations to public works, transportation, commerce, public protection, and health services.",
+      role: 'assistant',
+      options: {}
+    }
+  },
+  sources: [Getter]
+}
+```
+
 Once again we see a `toolResult`. You can see the query the LLM decided to send to the query engine ("total budget"), and the output the engine returned. In `response.message` you see that the LLM has returned the output from the tool almost verbatim, although it trimmed out the bit about 2024-2025 since we didn't ask about that year.
 
-### Comparison of Approaches
-
-The `OpenAIContextAwareAgent` approach simplifies the setup by allowing you to directly link the retriever to the agent, making it straightforward to access relevant context for your queries. This is ideal for situations where you want easy integration with existing data sources, like a context chat engine.
-
-On the other hand, using the `QueryEngineTool` offers more flexibility and power. This method allows for customization in how queries are constructed and executed, enabling you to query data from various storages and process them in different ways. However, this added flexibility comes with increased complexity and response time due to the separate tool call and queryEngine generating tool output by LLM that is then passed to the agent.
-
 So now we have an agent that can index complicated documents and answer questions about them. Let's [combine our math agent and our RAG agent](rag_and_tools)!

apps/docs/docs/guides/agents/5_rag_and_tools.mdx

@@ -1,6 +1,4 @@
----
-title: A RAG agent that does math
----
+# A RAG agent that does math
 
 In [our third iteration of the agent](https://github.com/run-llama/ts-agents/blob/main/3_rag_and_tools/agent.ts) we've combined the two previous agents, so we've defined both `sumNumbers` and a `QueryEngineTool` and created an array of two tools:
 

apps/docs/docs/guides/agents/6_llamaparse.mdx

@@ -1,6 +1,4 @@
----
-title: Adding LlamaParse
----
+# Adding LlamaParse
 
 Complicated PDFs can be very tricky for LLMs to understand. To help with this, LlamaIndex provides LlamaParse, a hosted service that parses complex documents including PDFs. To use it, get a `LLAMA_CLOUD_API_KEY` by [signing up for LlamaCloud](https://cloud.llamaindex.ai/) (it's free for up to 1000 pages/day) and adding it to your `.env` file just as you did for your OpenAI key:
 

apps/docs/docs/guides/agents/7_qdrant.mdx

@@ -1,6 +1,4 @@
----
-title: Adding persistent vector storage
----
+# Adding persistent vector storage
 
 In the previous examples, we've been loading our data into memory each time we run the agent. This is fine for small datasets, but for larger datasets you'll want to store your embeddings in a database. LlamaIndex.TS provides a `VectorStore` class that can store your embeddings in a variety of databases. We're going to use [Qdrant](https://qdrant.tech/), a popular vector store, for this example.
 

apps/docs/docs/guides/agents/_category_.yml

@@ -0,0 +1,2 @@
+label: Agents
+position: 1

apps/docs/docs/introduction.md

@@ -0,0 +1,54 @@
+---
+sidebar_position: 0
+slug: /
+---
+
+# What is LlamaIndex?
+
+LlamaIndex is a framework for building LLM-powered applications. LlamaIndex helps you ingest, structure, and access private or domain-specific data. It's available [as a Python package](https://docs.llamaindex.ai/en/stable/) and in TypeScript (this package). LlamaIndex.TS offers the core features of LlamaIndex for popular runtimes like Node.js (official support), Vercel Edge Functions (experimental), and Deno (experimental).
+
+## 🚀 Why LlamaIndex.TS?
+
+LLMs offer a natural language interface between humans and inferred data. Widely available models come pre-trained on huge amounts of publicly available data, from Wikipedia and mailing lists to textbooks and source code.
+
+Applications built on top of LLMs often require augmenting these models with private or domain-specific data. That data is often distributed across siloed applications and data stores. It's behind APIs, in SQL databases, or trapped in PDFs and slide decks.
+
+LlamaIndex.TS helps you unlock that data and then build powerful applications with it.
+
+## 🦙 What is LlamaIndex for?
+
+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 interactive, unsupervised manner.
+
+## 👨‍👩‍👧‍👦 Who is LlamaIndex for?
+
+LlamaIndex targets the "AI Engineer": developers building software in any domain that can be enhanced by LLM-powered functionality, without needing to be an expert in machine learning or natural language processing.
+
+Our high-level API allows beginner users to use LlamaIndex.TS to ingest, index, and query their data in just a few lines of code.
+
+For more complex applications, our lower-level APIs allow advanced users to customize and extend any module—data connectors, indices, retrievers, and query engines, to fit their needs.
+
+## Getting Started
+
+`npm install llamaindex`
+
+Our documentation includes [Installation Instructions](./getting_started/installation.mdx) and a [Starter Tutorial](./getting_started/starter_tutorial/retrieval_augmented_generation.mdx) to build your first application.
+
+Once you're up and running, [High-Level Concepts](./getting_started/concepts.md) has an overview of LlamaIndex's modular architecture. For more hands-on practical examples, look through our Examples section on the sidebar.
+
+## 🗺️ Ecosystem
+
+To download or contribute, find LlamaIndex on:
+
+- Github: https://github.com/run-llama/LlamaIndexTS
+- NPM: https://www.npmjs.com/package/llamaindex
+
+## Community
+
+Need help? Have a feature suggestion? Join the LlamaIndex community:
+
+- Twitter: https://twitter.com/llama_index
+- Discord https://discord.gg/dGcwcsnxhU

apps/docs/docs/modules/_category_.yml

@@ -0,0 +1,3 @@
+label: "Modules"
+collapsed: false
+position: 5

apps/docs/docs/modules/agent/_category_.yml

@@ -0,0 +1,2 @@
+label: "Agents"
+position: 10

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

@@ -1,6 +1,4 @@
----
-title: Agents
----
+# Agents
 
 An “agent” is an automated reasoning and decision engine. It takes in a user input/query and can make internal decisions for executing that query in order to return the correct result. The key agent components can include, but are not limited to:
 
@@ -21,11 +19,11 @@ LlamaIndex.TS comes with a few built-in agents, but you can also create your own
 
 ## Examples
 
-- [OpenAI Agent](/docs/llamaindex/examples/agent)
-- [Gemini Agent](/docs/llamaindex/examples/agent_gemini)
+- [OpenAI Agent](../../examples/agent.mdx)
+- [Gemini Agent](../../examples/agent_gemini.mdx)
 
 ## Api References
 
-- [OpenAIAgent](/docs/api/classes/OpenAIAgent)
-- [AnthropicAgent](/docs/api/classes/AnthropicAgent)
-- [ReActAgent](/docs/api/classes/ReActAgent)
+- [OpenAIAgent](../../api/classes/OpenAIAgent.md)
+- [AnthropicAgent](../../api/classes/AnthropicAgent.md)
+- [ReActAgent](../../api/classes/ReActAgent.md)

apps/docs/docs/modules/chat_engine.md

@@ -1,7 +1,9 @@
 ---
-title: ChatEngine
+sidebar_position: 13
 ---
 
+# ChatEngine
+
 The chat engine is a quick and simple way to chat with the data in your index.
 
 ```typescript
@@ -23,6 +25,6 @@ for await (const chunk of stream) {
 
 ## Api References
 
-- [ContextChatEngine](/docs/api/classes/ContextChatEngine)
-- [CondenseQuestionChatEngine](/docs/api/classes/ContextChatEngine)
-- [SimpleChatEngine](/docs/api/classes/SimpleChatEngine)
+- [ContextChatEngine](../api/classes/ContextChatEngine.md)
+- [CondenseQuestionChatEngine](../api/classes/ContextChatEngine.md)
+- [SimpleChatEngine](../api/classes/SimpleChatEngine.md)

apps/docs/docs/modules/data_index.md

@@ -1,7 +1,9 @@
 ---
-title: Index
+sidebar_position: 12
 ---
 
+# Index
+
 An index is the basic container and organization for your data. LlamaIndex.TS supports two indexes:
 
 - `VectorStoreIndex` - will send the top-k `Node`s to the LLM when generating a response. The default top-k is 2.
@@ -18,6 +20,6 @@ const index = await VectorStoreIndex.fromDocuments([document]);
 
 ## API Reference
 
-- [SummaryIndex](/docs/api/classes/SummaryIndex)
-- [VectorStoreIndex](/docs/api/classes/VectorStoreIndex)
-- [KeywordTableIndex](/docs/api/classes/KeywordTableIndex)
+- [SummaryIndex](../api/classes/SummaryIndex.md)
+- [VectorStoreIndex](../api/classes/VectorStoreIndex.md)
+- [KeywordTableIndex](../api/classes/KeywordTableIndex.md)

apps/docs/docs/modules/data_loaders/_category_.yml

@@ -0,0 +1,2 @@
+label: "Loaders"
+position: 1

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

@@ -1,9 +1,7 @@
----
-title: DiscordReader
----
+import CodeBlock from "@theme/CodeBlock";
+import CodeSource from "!raw-loader!../../../../../examples/readers/src/discord";
 
-import { DynamicCodeBlock } from 'fumadocs-ui/components/dynamic-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.
@@ -15,7 +13,7 @@ In your Discord Application, go to the `OAuth2` tab and generate an invite URL b
 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.
 
-<DynamicCodeBlock lang="ts" code={CodeSource} />
+<CodeBlock language="ts">{CodeSource}</CodeBlock>
 
 ### Params
 
@@ -33,4 +31,4 @@ Copy the URL in your browser and select the server you want your bot to join.
 
 ## API Reference
 
-- [DiscordReader](/docs/api/classes/DiscordReader)
+- [DiscordReader](../../api/classes/DiscordReader.md)

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

@@ -0,0 +1,58 @@
+import CodeBlock from "@theme/CodeBlock";
+import CodeSource from "!raw-loader!../../../../../examples/readers/src/simple-directory-reader";
+import CodeSource2 from "!raw-loader!../../../../../examples/readers/src/custom-simple-directory-reader";
+
+# Loader
+
+Before you can start indexing your documents, you need to load them into memory.
+
+All "basic" data loaders can be seen below, mapped to their respective filetypes in `SimpleDirectoryReader`. More loaders are shown in the sidebar on the left.
+Additionally the following loaders exist without separate documentation:
+
+- `AssemblyAIReader` transcribes audio using [AssemblyAI](https://www.assemblyai.com/).
+  - [AudioTranscriptReader](../../api/classes/AudioTranscriptReader.md): loads entire transcript as a single document.
+  - [AudioTranscriptParagraphsReader](../../api/classes/AudioTranscriptParagraphsReader.md): creates a document per paragraph.
+  - [AudioTranscriptSentencesReader](../../api/classes/AudioTranscriptSentencesReader.md): creates a document per sentence.
+  - [AudioSubtitlesReader](../../api/classes/AudioTranscriptParagraphsReader.md): creates a document containing the subtitles of a transcript.
+- [NotionReader](../../api/classes/NotionReader.md) loads [Notion](https://www.notion.so/) pages.
+- [SimpleMongoReader](../../api/classes/SimpleMongoReader) loads data from a [MongoDB](https://www.mongodb.com/).
+
+Check the [LlamaIndexTS Github](https://github.com/run-llama/LlamaIndexTS) for the most up to date overview of integrations.
+
+## SimpleDirectoryReader
+
+[![Open in StackBlitz](https://developer.stackblitz.com/img/open_in_stackblitz.svg)](https://stackblitz.com/github/run-llama/LlamaIndexTS/tree/main/examples/readers?file=src/simple-directory-reader.ts&title=Simple%20Directory%20Reader)
+
+LlamaIndex.TS supports easy loading of files from folders using the `SimpleDirectoryReader` class.
+
+It is a simple reader that reads all files from a directory and its subdirectories.
+
+<CodeBlock language="ts">{CodeSource}</CodeBlock>
+
+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:
+
+- `overrideReader` overrides the reader for all file types, including unsupported ones.
+- `fileExtToReader` maps a reader to a specific file type. Can override reader for existing file types or add support for new file types.
+- `defaultReader` sets a fallback reader for files with unsupported extensions. By default it is `TextFileReader`.
+
+SimpleDirectoryReader supports up to 9 concurrent requests. Use the `numWorkers` option to set the number of concurrent requests. By default it runs in sequential mode, i.e. set to 1.
+
+### Example
+
+<CodeBlock language="ts" showLineNumbers metastring="{8-12,17-21}">
+  {CodeSource2}
+</CodeBlock>
+
+## API Reference
+
+- [SimpleDirectoryReader](../../api/classes/SimpleDirectoryReader.md)

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

@@ -1,6 +1,4 @@
----
-title: JSONReader
----
+# 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.
@@ -41,6 +39,7 @@ Depth-First-Traversal:
 
 #### Examples
 
+<!-- prettier-ignore-start -->
 Input:
 
 ```json
@@ -143,7 +142,8 @@ Output:
 
 "tweet": "こんにちは世界"
 ```
+<!-- prettier-ignore-end -->
 
 ## API Reference
 
-- [JSONReader](/docs/api/classes/JSONReader)
+- [JSONReader](../../api/classes/JSONReader.md)

apps/docs/docs/modules/data_loaders/llama_parse/_category_.yml

@@ -0,0 +1 @@
+label: "LlamaParse"

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

@@ -1,7 +1,9 @@
 ---
-title: Image Retrieval
+sidebar_position: 2
 ---
 
+# Image Retrieval
+
 LlamaParse `json` mode supports extracting any images found in a page object by using the `getImages` function. They are downloaded to a local folder and can then be sent to a multimodal LLM for further processing.
 
 ## Usage
@@ -112,4 +114,4 @@ You can see the full example file [here](https://github.com/run-llama/LlamaIndex
 
 ## API Reference
 
-- [LlamaParseReader](/docs/api/classes/LlamaParseReader)
+- [LlamaParseReader](../../../api/classes/LlamaParseReader.md)

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

@@ -1,10 +1,8 @@
----
-title: LlamaParse
----
+import CodeBlock from "@theme/CodeBlock";
+import CodeSource from "!raw-loader!../../../../../../examples/readers/src/llamaparse";
+import CodeSource2 from "!raw-loader!../../../../../../examples/readers/src/simple-directory-reader-with-llamaparse.ts";
 
-import { DynamicCodeBlock } from 'fumadocs-ui/components/dynamic-codeblock';
-import CodeSource from "!raw-loader!../../../../../../../../../examples/readers/src/llamaparse";
-import CodeSource2 from "!raw-loader!../../../../../../../../../examples/readers/src/simple-directory-reader-with-llamaparse.ts";
+# LlamaParse
 
 LlamaParse is an API created by LlamaIndex to efficiently parse files, e.g. it's great at converting PDF tables into markdown.
 
@@ -17,7 +15,7 @@ Official documentation for LlamaParse can be found [here](https://docs.cloud.lla
 You can then use the `LlamaParseReader` class to load local files and convert them into a parsed document that can be used by LlamaIndex.
 See [reader.ts](https://github.com/run-llama/LlamaIndexTS/blob/main/packages/cloud/src/reader.ts) for a list of supported file types:
 
-<DynamicCodeBlock lang="ts" code={CodeSource} />
+<CodeBlock language="ts">{CodeSource}</CodeBlock>
 
 ### Params
 
@@ -36,7 +34,7 @@ They can be divided into two groups.
 #### Advanced params:
 
 - `resultType` can be set to `markdown`, `text` or `json`. Defaults to `text`. More information about `json` mode on the next pages.
-- `language` primarily helps with OCR recognition. Defaults to `en`. Click [here](/docs/api/type-aliases/Language) 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`.
@@ -60,9 +58,9 @@ They can be divided into two groups.
 
 Below a full example of `LlamaParse` integrated in `SimpleDirectoryReader` with additional options.
 
-<DynamicCodeBlock lang="ts" code={CodeSource2} />
+<CodeBlock language="ts">{CodeSource2}</CodeBlock>
 
 ## API Reference
 
-- [SimpleDirectoryReader](/docs/api/classes/SimpleDirectoryReader)
-- [LlamaParseReader](/docs/api/classes/LlamaParseReader)
+- [SimpleDirectoryReader](../../../api/classes/SimpleDirectoryReader.md)
+- [LlamaParseReader](../../../api/classes/LlamaParseReader.md)

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

@@ -1,7 +1,9 @@
 ---
-title: JSON Mode
+sidebar_position: 1
 ---
 
+# JSON Mode
+
 In JSON mode, LlamaParse will return a data structure representing the parsed object.
 
 ## Usage
@@ -89,5 +91,5 @@ You can assign any other values of the JSON response to the Document as needed.
 
 ## API Reference
 
-- [LlamaParseReader](/docs/api/classes/LlamaParseReader)
-- [SimpleDirectoryReader](/docs/api/classes/SimpleDirectoryReader)
+- [LlamaParseReader](../../../api/classes/LlamaParseReader.md)
+- [SimpleDirectoryReader](../../../api/classes/SimpleDirectoryReader.md)

apps/docs/docs/modules/data_stores/_category_.yml

@@ -0,0 +1,2 @@
+label: "Data Stores"
+position: 2

apps/docs/docs/modules/data_stores/chat_stores/_category_.yml

@@ -0,0 +1 @@
+label: "Chat Stores"

apps/docs/docs/modules/data_stores/chat_stores/index.md

@@ -1,16 +1,13 @@
----
-title: Chat Stores
----
+# Chat Stores
 
 Chat stores manage chat history by storing sequences of messages in a structured way, ensuring the order of messages is maintained for accurate conversation flow.
 
 ## Available Chat Stores
 
-- [SimpleChatStore](/docs/api/classes/SimpleChatStore): A simple in-memory chat store with support for [persisting](/docs/llamaindex/modules/data_stores/#local-storage) data to disk.
+- [SimpleChatStore](../../../api/classes/SimpleChatStore.md): A simple in-memory chat store with support for [persisting](../index.md#local-storage) data to disk.
 
 Check the [LlamaIndexTS Github](https://github.com/run-llama/LlamaIndexTS) for the most up to date overview of integrations.
 
 ## API Reference
 
-- [BaseChatStore](/docs/api/interfaces/BaseChatStore)
-
+- [BaseChatStore](../../../api/interfaces/BaseChatStore.md)

apps/docs/docs/modules/data_stores/doc_stores/_category_.yml

@@ -0,0 +1,2 @@
+label: "Document Stores"
+position: 2

apps/docs/docs/modules/data_stores/doc_stores/index.md

@@ -0,0 +1,14 @@
+# Document Stores
+
+Document stores contain ingested document chunks, i.e. [Node](../../documents_and_nodes/index.md)s.
+
+## Available Document Stores
+
+- [SimpleDocumentStore](../../../api/classes/SimpleDocumentStore.md): A simple in-memory document store with support for [persisting](../index.md#local-storage) data to disk.
+- [PostgresDocumentStore](../../../api/classes/PostgresDocumentStore.md): A PostgreSQL document store, see [PostgreSQL Storage](../index.md#postgresql-storage).
+
+Check the [LlamaIndexTS Github](https://github.com/run-llama/LlamaIndexTS) for the most up to date overview of integrations.
+
+## API Reference
+
+- [BaseDocumentStore](../../../api/classes/BaseDocumentStore.md)

apps/docs/docs/modules/data_stores/index.md

@@ -1,6 +1,4 @@
----
-title: Storage
----
+# Storage
 
 Storage in LlamaIndex.TS works automatically once you've configured a
 `StorageContext` object.
@@ -55,4 +53,4 @@ const index = await VectorStoreIndex.fromDocuments([document], {
 
 ## API Reference
 
-- [StorageContext](/docs/api/interfaces/StorageContext)
+- [StorageContext](../../api/interfaces/StorageContext.md)

apps/docs/docs/modules/data_stores/index_stores/_category_.yml

@@ -0,0 +1,2 @@
+label: "Index Stores"
+position: 3

apps/docs/docs/modules/data_stores/index_stores/index.md

@@ -0,0 +1,14 @@
+# Index Stores
+
+Index stores are underlying storage components that contain metadata(i.e. information created when indexing) about the [index](../../data_index.md) itself.
+
+## Available Index Stores
+
+- [SimpleIndexStore](../../../api/classes/SimpleIndexStore.md): A simple in-memory index store with support for [persisting](../index.md#local-storage) data to disk.
+- [PostgresIndexStore](../../../api/classes/PostgresIndexStore.md): A PostgreSQL index store, , see [PostgreSQL Storage](../index.md#postgresql-storage).
+
+Check the [LlamaIndexTS Github](https://github.com/run-llama/LlamaIndexTS) for the most up to date overview of integrations.
+
+## API Reference
+
+- [BaseIndexStore](../../../api/classes/BaseIndexStore.md)

apps/docs/docs/modules/data_stores/kv_stores/_category_.yml

@@ -0,0 +1,2 @@
+label: "Key-Value Stores"
+position: 4

apps/docs/docs/modules/data_stores/kv_stores/index.md

@@ -0,0 +1,14 @@
+# Key-Value Stores
+
+Key-Value Stores represent underlying storage components used in [Document Stores](../doc_stores/index.md) and [Index Stores](../index_stores/index.md)
+
+## Available Key-Value Stores
+
+- [SimpleKVStore](../../../api/classes/SimpleKVStore.md): A simple Key-Value store with support of [persisting](../index.md#local-storage) data to disk.
+- [PostgresKVStore](../../../api/classes/PostgresKVStore.md): A PostgreSQL Key-Value store, see [PostgreSQL Storage](../index.md#postgresql-storage).
+
+Check the [LlamaIndexTS Github](https://github.com/run-llama/LlamaIndexTS) for the most up to date overview of integrations.
+
+## API Reference
+
+- [BaseKVStore](../../../api/classes/BaseKVStore.md)

apps/docs/docs/modules/data_stores/vector_stores/_category_.yml

@@ -0,0 +1,2 @@
+label: "Vector Stores"
+position: 1

apps/docs/docs/modules/data_stores/vector_stores/index.md

@@ -0,0 +1,22 @@
+# Vector Stores
+
+Vector stores save embedding vectors of your ingested document chunks.
+
+## Available Vector Stores
+
+Available Vector Stores are shown on the sidebar to the left. Additionally the following integrations exist without separate documentation:
+
+- [SimpleVectorStore](../../../api/classes/SimpleVectorStore.md): A simple in-memory vector store with optional [persistance](../index.md#local-storage) to disk.
+- [AstraDBVectorStore](../../../api/classes/AstraDBVectorStore.md): A cloud-native, scalable Database-as-a-Service built on Apache Cassandra, see [datastax.com](https://www.datastax.com/products/datastax-astra)
+- [ChromaVectorStore](../../../api/classes/ChromaVectorStore.md): An open-source vector database, focused on ease of use and performance, see [trychroma.com](https://www.trychroma.com/)
+- [MilvusVectorStore](../../../api/classes/MilvusVectorStore.md): An open-source, high-performance, highly scalable vector database, see [milvus.io](https://milvus.io/)
+- [MongoDBAtlasVectorSearch](../../../api/classes/MongoDBAtlasVectorSearch.md): A cloud-based vector search solution for MongoDB, see [mongodb.com](https://www.mongodb.com/products/platform/atlas-vector-search)
+- [PGVectorStore](../../../api/classes/PGVectorStore.md): An open-source vector store built on PostgreSQL, see [pgvector Github](https://github.com/pgvector/pgvector)
+- [PineconeVectorStore](../../../api/classes/PineconeVectorStore.md): A managed, cloud-native vector database, see [pinecone.io](https://www.pinecone.io/)
+- [WeaviateVectorStore](../../../api/classes/WeaviateVectorStore.md): An open-source, ai-native vector database, see [weaviate.io](https://weaviate.io/)
+
+Check the [LlamaIndexTS Github](https://github.com/run-llama/LlamaIndexTS) for the most up to date overview of integrations.
+
+## API Reference
+
+- [VectorStoreBase](../../../api/classes/VectorStoreBase.md)

apps/docs/docs/modules/data_stores/vector_stores/qdrant.md

@@ -1,6 +1,4 @@
----
-title: Qdrant Vector Store
----
+# Qdrant Vector Store
 
 [qdrant.tech](https://qdrant.tech/)
 
@@ -91,4 +89,4 @@ main().catch(console.error);
 
 ## API Reference
 
-- [QdrantVectorStore](/docs/api/classes/QdrantVectorStore)
+- [QdrantVectorStore](../../../api/classes/QdrantVectorStore.md)

apps/docs/docs/modules/documents_and_nodes/_category_.yml

@@ -0,0 +1,2 @@
+label: "Document / Nodes"
+position: 0

apps/docs/docs/modules/documents_and_nodes/index.md

@@ -1,6 +1,4 @@
----
-title: Documents and Nodes
----
+# Documents and Nodes
 
 `Document`s and `Node`s are the basic building blocks of any index. While the API for these objects is similar, `Document` objects represent entire files, while `Node`s are smaller pieces of that original document, that are suitable for an LLM and Q&A.
 
@@ -12,5 +10,5 @@ document = new Document({ text: "text", metadata: { key: "val" } });
 
 ## API Reference
 
-- [Document](/docs/api/classes/Document)
-- [TextNode](/docs/api/classes/TextNode)
+- [Document](../../api/classes/Document.md)
+- [TextNode](../../api/classes/TextNode.md)

apps/docs/docs/modules/documents_and_nodes/metadata_extraction.md

@@ -1,6 +1,4 @@
----
-title: Metadata Extraction Usage Pattern
----
+# Metadata Extraction Usage Pattern
 
 You can use LLMs to automate metadata extraction with our `Metadata Extractor` modules.
 
@@ -48,7 +46,7 @@ main().then(() => console.log("done"));
 
 ## API Reference
 
-- [SummaryExtractor](/docs/api/classes/SummaryExtractor)
-- [QuestionsAnsweredExtractor](/docs/api/classes/QuestionsAnsweredExtractor)
-- [TitleExtractor](/docs/api/classes/TitleExtractor)
-- [KeywordExtractor](/docs/api/classes/KeywordExtractor)
+- [SummaryExtractor](../../api/classes/SummaryExtractor.md)
+- [QuestionsAnsweredExtractor](../../api/classes/QuestionsAnsweredExtractor.md)
+- [TitleExtractor](../../api/classes/TitleExtractor.md)
+- [KeywordExtractor](../../api/classes/KeywordExtractor.md)

apps/docs/docs/modules/embeddings/_category_.yml

@@ -0,0 +1,2 @@
+label: "Embeddings"
+position: 6

apps/docs/docs/modules/embeddings/available_embeddings/_category_.yml

@@ -0,0 +1 @@
+label: "Available Embeddings"

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

@@ -1,6 +1,4 @@
----
-title: DeepInfra
----
+# DeepInfra
 
 To use DeepInfra embeddings, you need to import `DeepInfraEmbedding` from llamaindex.
 Check out available embedding models [here](https://deepinfra.com/models/embeddings).
@@ -82,4 +80,4 @@ For questions or feedback, please contact us at [feedback@deepinfra.com](mailto:
 
 ## API Reference
 
-- [DeepInfraEmbedding](/docs/api/classes/DeepInfraEmbedding)
+- [DeepInfraEmbedding](../../../api/classes/DeepInfraEmbedding.md)

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

@@ -1,6 +1,4 @@
----
-title: Gemini
----
+# Gemini
 
 To use Gemini embeddings, you need to import `GeminiEmbedding` from `llamaindex`.
 
@@ -36,4 +34,4 @@ Settings.embedModel = new GeminiEmbedding({
 
 ## API Reference
 
-- [GeminiEmbedding](/docs/api/classes/GeminiEmbedding)
+- [GeminiEmbedding](../../../api/classes/GeminiEmbedding.md)

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

@@ -1,6 +1,4 @@
----
-title: HuggingFace
----
+# HuggingFace
 
 To use HuggingFace embeddings, you need to import `HuggingFaceEmbedding` from `llamaindex`.
 
@@ -37,4 +35,4 @@ Settings.embedModel = new HuggingFaceEmbedding({
 
 ## API Reference
 
-- [HuggingFaceEmbedding](/docs/api/classes/HuggingFaceEmbedding)
+- [HuggingFaceEmbedding](../../../api/classes/HuggingFaceEmbedding.md)

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

@@ -1,6 +1,4 @@
----
-title: Jina AI
----
+# Jina AI
 
 To use Jina AI embeddings, you need to import `JinaAIEmbedding` from `llamaindex`.
 
@@ -24,4 +22,4 @@ const results = await queryEngine.query({
 
 ## API Reference
 
-- [JinaAIEmbedding](/docs/api/classes/JinaAIEmbedding)
+- [JinaAIEmbedding](../../../api/classes/JinaAIEmbedding.md)

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

@@ -1,6 +1,4 @@
----
-title: MistralAI
----
+# MistralAI
 
 To use MistralAI embeddings, you need to import `MistralAIEmbedding` from `llamaindex`.
 
@@ -27,4 +25,4 @@ const results = await queryEngine.query({
 
 ## API Reference
 
-- [MistralAIEmbedding](/docs/api/classes/MistralAIEmbedding)
+- [MistralAIEmbedding](../../../api/classes/MistralAIEmbedding.md)

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

@@ -1,6 +1,4 @@
----
-title: MixedbreadAI
----
+# 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.
 
@@ -103,4 +101,4 @@ console.log(result); // Perfectly customized embeddings, ready to serve.
 
 ## API Reference
 
-- [MixedbreadAIEmbeddings](/docs/api/classes/MixedbreadAIEmbeddings)
+- [MixedbreadAIEmbeddings](../../../api/classes/MixedbreadAIEmbeddings.md)

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

@@ -1,6 +1,4 @@
----
-title: Ollama
----
+# Ollama
 
 To use Ollama embeddings, you need to import `OllamaEmbedding` from `llamaindex`.
 
@@ -32,4 +30,4 @@ const results = await queryEngine.query({
 
 ## API Reference
 
-- [OllamaEmbedding](/docs/api/classes/OllamaEmbedding)
+- [OllamaEmbedding](../../../api/classes/OllamaEmbedding.md)

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

@@ -1,6 +1,4 @@
----
-title: OpenAI
----
+# OpenAI
 
 To use OpenAI embeddings, you need to import `OpenAIEmbedding` from `llamaindex`.
 
@@ -24,4 +22,4 @@ const results = await queryEngine.query({
 
 ## API Reference
 
-- [OpenAIEmbedding](/docs/api/classes/OpenAIEmbedding)
+- [OpenAIEmbedding](../../../api/classes/OpenAIEmbedding.md)

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

@@ -1,6 +1,4 @@
----
-title: Together
----
+# Together
 
 To use together embeddings, you need to import `TogetherEmbedding` from `llamaindex`.
 
@@ -26,4 +24,4 @@ const results = await queryEngine.query({
 
 ## API Reference
 
-- [TogetherEmbedding](/docs/api/classes/TogetherEmbedding)
+- [TogetherEmbedding](../../../api/classes/TogetherEmbedding.md)

apps/docs/docs/modules/embeddings/index.md

@@ -1,6 +1,4 @@
----
-title: Embedding
----
+# Embedding
 
 The embedding model in LlamaIndex is responsible for creating numerical representations of text. By default, LlamaIndex will use the `text-embedding-ada-002` model from OpenAI.
 
@@ -16,18 +14,18 @@ Settings.embedModel = new OpenAIEmbedding({
 
 ## Local Embedding
 
-For local embeddings, you can use the [HuggingFace](/docs/llamaindex/modules/embeddings/available_embeddings/huggingface) embedding model.
+For local embeddings, you can use the [HuggingFace](./available_embeddings/huggingface.md) embedding model.
 
 ## Available Embeddings
 
 Most available embeddings are listed in the sidebar on the left.
 Additionally the following integrations exist without separate documentation:
 
-- [ClipEmbedding](/docs/api/classes/ClipEmbedding) using `@xenova/transformers`
-- [FireworksEmbedding](/docs/api/classes/FireworksEmbedding) see [fireworks.ai](https://fireworks.ai/)
+- [ClipEmbedding](../../api/classes/ClipEmbedding.md) using `@xenova/transformers`
+- [FireworksEmbedding](../../api/classes/FireworksEmbedding.md) see [fireworks.ai](https://fireworks.ai/)
 
 Check the [LlamaIndexTS Github](https://github.com/run-llama/LlamaIndexTS) for the most up to date overview of integrations.
 
 ## API Reference
 
-- [OpenAIEmbedding](/docs/api/classes/OpenAIEmbedding)
+- [OpenAIEmbedding](../../api/classes/OpenAIEmbedding.md)

apps/docs/docs/modules/evaluation/_category_.yml

@@ -0,0 +1,2 @@
+label: "Evaluating"
+position: 9

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

@@ -1,6 +1,4 @@
----
-title: Evaluating
----
+# Evaluating
 
 ## Concept
 
@@ -29,6 +27,6 @@ These evaluation modules are in the following forms:
 
 ## Usage
 
-- [Correctness Evaluator](/docs/llamaindex/modules/evaluation/correctness)
-- [Faithfulness Evaluator](/docs/llamaindex/modules/evaluation/faithfulness)
-- [Relevancy Evaluator](/docs/llamaindex/modules/evaluation/relevancy)
+- [Correctness Evaluator](./modules/correctness.md)
+- [Faithfulness Evaluator](./modules/faithfulness.md)
+- [Relevancy Evaluator](./modules/relevancy.md)

apps/docs/docs/modules/evaluation/modules/_category_.yml

@@ -0,0 +1 @@
+label: "Modules"

apps/docs/docs/modules/evaluation/modules/correctness.md

@@ -1,6 +1,4 @@
----
-title: Correctness Evaluator
----
+# Correctness Evaluator
 
 Correctness evaluates the relevance and correctness of a generated answer against a reference answer.
 
@@ -61,4 +59,4 @@ the response is not correct with a score of 2.5
 
 ## API Reference
 
-- [CorrectnessEvaluator](/docs/api/classes/CorrectnessEvaluator)
+- [CorrectnessEvaluator](../../../api/classes/CorrectnessEvaluator.md)

apps/docs/docs/modules/evaluation/modules/faithfulness.md

@@ -1,6 +1,4 @@
----
-title: Faithfulness Evaluator
----
+# Faithfulness Evaluator
 
 Faithfulness is a measure of whether the generated answer is faithful to the retrieved contexts. In other words, it measures whether there is any hallucination in the generated answer.
 
@@ -81,4 +79,4 @@ the response is faithful
 
 ## API Reference
 
-- [FaithfulnessEvaluator](/docs/api/classes/FaithfulnessEvaluator)
+- [FaithfulnessEvaluator](../../../api/classes/FaithfulnessEvaluator.md)

apps/docs/docs/modules/evaluation/modules/relevancy.md

@@ -1,6 +1,4 @@
----
-title: Relevancy Evaluator
----
+# Relevancy Evaluator
 
 Relevancy measure if the response from a query engine matches any source nodes.
 
@@ -75,4 +73,4 @@ the response is relevant
 
 ## API Reference
 
-- [RelevancyEvaluator](/docs/api/classes/RelevancyEvaluator)
+- [RelevancyEvaluator](../../../api/classes/RelevancyEvaluator.md)

apps/docs/docs/modules/ingestion_pipeline/_category_.yml

@@ -0,0 +1,2 @@
+label: "Ingestion Pipeline"
+position: 4

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

@@ -1,6 +1,4 @@
----
-title: Ingestion Pipeline
----
+# Ingestion Pipeline
 
 An `IngestionPipeline` uses a concept of `Transformations` that are applied to input data.
 These `Transformations` are applied to your input data, and the resulting nodes are either returned or inserted into a vector database (if given).
@@ -102,4 +100,4 @@ main().catch(console.error);
 
 ## API Reference
 
-- [IngestionPipeline](/docs/api/classes/IngestionPipeline)
+- [IngestionPipeline](../../api/classes/IngestionPipeline.md)

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

@@ -1,14 +1,12 @@
----
-title: Transformations
----
+# Transformations
 
 A transformation is something that takes a list of nodes as an input, and returns a list of nodes. Each component that implements the Transformation class has both a `transform` definition responsible for transforming the nodes.
 
 Currently, the following components are Transformation objects:
 
-- [SentenceSplitter](/docs/api/classes/SentenceSplitter)
-- [MetadataExtractor](/docs/llamaindex/modules/documents_and_nodes/metadata_extraction)
-- [Embeddings](/docs/llamaindex/modules/embeddings/index)
+- [SentenceSplitter](../../api/classes/SentenceSplitter.md)
+- [MetadataExtractor](../documents_and_nodes/metadata_extraction.md)
+- [Embeddings](../embeddings/index.md)
 
 ## Usage Pattern
 
@@ -80,4 +78,4 @@ main().catch(console.error);
 
 ## API Reference
 
-- [TransformComponent](/docs/api/classes/TransformComponent)
+- [TransformComponent](../../api/classes/TransformComponent.md)

apps/docs/docs/modules/llamacloud.mdx

@@ -1,9 +1,7 @@
----
-title: LlamaCloud
----
+import CodeBlock from "@theme/CodeBlock";
+import CodeSource from "!raw-loader!../../../../examples/cloud/chat.ts";
 
-import { DynamicCodeBlock } from 'fumadocs-ui/components/dynamic-codeblock';
-import CodeSource from "!raw-loader!../../../../../../../examples/cloud/chat.ts";
+# LlamaCloud
 
 LlamaCloud is a new generation of managed parsing, ingestion, and retrieval services, designed to bring production-grade context-augmentation to your LLM and RAG applications.
 
@@ -26,9 +24,9 @@ Currently, you can't create a managed index on LlamaCloud using LlamaIndexTS, bu
 
 Here's an example of how to use a managed index together with a chat engine:
 
-<DynamicCodeBlock lang="ts" code={CodeSource} />
+<CodeBlock language="ts">{CodeSource}</CodeBlock>
 
 ## API Reference
 
-- [LlamaCloudIndex](/docs/api/classes/LlamaCloudIndex)
-- [LlamaCloudRetriever](/docs/api/classes/LlamaCloudRetriever)
+- [LlamaCloudIndex](../api/classes/LlamaCloudIndex.md)
+- [LlamaCloudRetriever](../api/classes/LlamaCloudRetriever.md)

apps/docs/docs/modules/llms/_category_.yml

@@ -0,0 +1,2 @@
+label: "LLMs"
+position: 5

apps/docs/docs/modules/llms/available_llms/_category_.yml

@@ -0,0 +1 @@
+label: "Available LLMs"