ensure build works

.changeset/chatty-numbers-attack.md

@@ -1,6 +0,0 @@
----
-"@llamaindex/workflow": patch
-"@llamaindex/core": patch
----
-
-Remove requireContext from tools - better use binding to pass context

.changeset/red-clocks-attack.md

@@ -1,5 +0,0 @@
----
-"@llamaindex/qdrant": patch
----
-
-Update implementation to use query instead of search which is being deprecated

.changeset/six-dryers-rescue.md

@@ -1,6 +0,0 @@
----
-"llamaindex": minor
-"@llamaindex/core": patch
----
-
-Remove old workflows - use @llamaindex/workflow package

.changeset/ten-toys-accept.md

@@ -0,0 +1,5 @@
+---
+"@llamaindex/openai": patch
+---
+
+Update o4-mini to accept reasoning parameters and exclude temperature

.changeset/wild-parents-look.md

@@ -1,6 +0,0 @@
----
-"@llamaindex/azure": patch
-"@llamaindex/openai": minor
----
-
-Move Azure models to azure package

.github/workflows/lint_on_push_or_pull.yml

@@ -8,11 +8,6 @@ on:
     branches:
       - main
 
-env:
-  TURBO_TOKEN: ${{ secrets.TURBO_TOKEN }}
-  TURBO_TEAM: ${{ vars.TURBO_TEAM }}
-  TURBO_REMOTE_ONLY: true
-
 jobs:
   lint:
     runs-on: ubuntu-latest

.github/workflows/preview.yml

@@ -1,11 +1,6 @@
 name: Publish Preview
 on: [pull_request]
 
-env:
-  TURBO_TOKEN: ${{ secrets.TURBO_TOKEN }}
-  TURBO_TEAM: ${{ vars.TURBO_TEAM }}
-  TURBO_REMOTE_ONLY: true
-
 jobs:
   pre_release:
     name: Pre Release

.github/workflows/test.yml

@@ -23,7 +23,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        node-version: [20.x, 22.x, 23.x]
+        node-version: [18.x, 20.x, 22.x, 23.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: [20.x, 22.x, 23.x]
+        node-version: [18.x, 20.x, 22.x, 23.x]
     name: Test on Node.js ${{ matrix.node-version }}
     runs-on: ubuntu-latest
     steps:
@@ -87,30 +87,6 @@ jobs:
         run: pnpm run type-check
       - name: Run Circular Dependency Check
         run: pnpm run circular-check
-  e2e-npm:
-    runs-on: ubuntu-latest
-    name: Test using packages with npm
-    steps:
-      - uses: actions/checkout@v4
-      - uses: pnpm/action-setup@v4
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version-file: ".nvmrc"
-      - name: Install dependencies
-        run: pnpm install
-      - name: Build packages
-        run: pnpm run build
-      - name: Pack packages
-        run: |
-          pnpm pack --pack-destination ${{ runner.temp }} -C packages/llamaindex
-          pnpm pack --pack-destination ${{ runner.temp }} -C packages/workflow
-      - name: Install packed packages
-        run: npm add ${{ runner.temp }}/*.tgz
-        working-directory: e2e/npm
-      - name: Run tests
-        run: npm test
-        working-directory: e2e/npm
   e2e-llamaindex-examples:
     strategy:
       fail-fast: false

.nvmrc

@@ -1 +1 @@
-22
+20

.prettierignore

@@ -7,4 +7,3 @@ dist/
 .source/
 # prttier doesn't support mdx3 we are using
 *.mdx
-packages/server/server/

README.md

@@ -7,10 +7,9 @@
 </h3>
 
 [![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://github.com/run-llama/LlamaIndexTS/blob/main/LICENSE)
+[![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)
-[![Twitter](https://img.shields.io/twitter/follow/llama_index)](https://x.com/llama_index)
 
 Use your own data with large language models (LLMs, OpenAI ChatGPT and others) in JS runtime environments with TypeScript support.
 
@@ -64,7 +63,7 @@ yarn add llamaindex
 
 ### Setup in Node.js, Deno, Bun, TypeScript...?
 
-See our official document: https://ts.llamaindex.ai/docs/llamaindex/getting_started
+See our official document: <https://ts.llamaindex.ai/docs/llamaindex/getting_started/>
 
 ### Adding provider packages
 
@@ -84,7 +83,19 @@ Check out our NextJS playground at https://llama-playground.vercel.app/. The sou
 
 ## Core concepts for getting started:
 
-See our documentation: https://ts.llamaindex.ai/docs/llamaindex/getting_started/concepts
+- [Document](/packages/llamaindex/src/Node.ts): A document represents a text file, PDF file or other contiguous piece of data.
+
+- [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 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.
+
+- [QueryEngine](/packages/llamaindex/src/engines/query/RetrieverQueryEngine.ts): Query engines are what generate the query you put in and give you back the result. Query engines generally combine a pre-built prompt with selected Nodes from your Index to give the LLM the context it needs to answer your query. To build a query engine from your Index (recommended), use the [`asQueryEngine`](/packages/llamaindex/src/indices/BaseIndex.ts) method on your Index. See all query engines [here](/packages/llamaindex/src/engines/query).
+
+- [ChatEngine](/packages/llamaindex/src/engines/chat/SimpleChatEngine.ts): A ChatEngine helps you build a chatbot that will interact with your Indices. See all chat engines [here](/packages/llamaindex/src/engines/chat).
+
+- [SimplePrompt](/packages/llamaindex/src/Prompt.ts): A simple standardized function call definition that takes in inputs and formats them in a template literal. SimplePrompts can be specialized using currying and combined using other SimplePrompt functions.
 
 ## Contributing:
 

apps/next/CHANGELOG.md

@@ -1,76 +1,5 @@
 # @llamaindex/doc
 
-## 0.2.18
-
-### Patch Changes
-
-- d671ed6: Add functionality for search params when querying Qdrant vector store.
-- Updated dependencies [76c9a80]
-- Updated dependencies [168d11f]
-- Updated dependencies [d671ed6]
-- Updated dependencies [40f5f41]
-  - @llamaindex/openai@0.3.7
-  - @llamaindex/workflow@1.1.2
-  - @llamaindex/core@0.6.5
-  - @llamaindex/cloud@4.0.7
-  - llamaindex@0.10.6
-  - @llamaindex/node-parser@2.0.5
-  - @llamaindex/readers@3.1.3
-
-## 0.2.17
-
-### Patch Changes
-
-- Updated dependencies [9b2e25a]
-  - @llamaindex/openai@0.3.6
-  - @llamaindex/core@0.6.4
-  - llamaindex@0.10.5
-  - @llamaindex/cloud@4.0.6
-  - @llamaindex/node-parser@2.0.4
-  - @llamaindex/readers@3.1.2
-  - @llamaindex/workflow@1.1.1
-
-## 0.2.16
-
-### Patch Changes
-
-- Updated dependencies [7e8e454]
-- Updated dependencies [2225ffd]
-- Updated dependencies [6ddf1c1]
-- Updated dependencies [bc53342]
-- Updated dependencies [41953a3]
-  - @llamaindex/workflow@1.1.0
-  - @llamaindex/cloud@4.0.5
-  - llamaindex@0.10.4
-
-## 0.2.15
-
-### Patch Changes
-
-- Updated dependencies [3ee8c83]
-  - @llamaindex/core@0.6.3
-  - llamaindex@0.10.3
-  - @llamaindex/openai@0.3.5
-  - @llamaindex/cloud@4.0.4
-  - @llamaindex/node-parser@2.0.3
-  - @llamaindex/readers@3.1.1
-  - @llamaindex/workflow@1.0.4
-
-## 0.2.14
-
-### Patch Changes
-
-- Updated dependencies [1e59695]
-  - @llamaindex/readers@3.1.0
-
-## 0.2.13
-
-### Patch Changes
-
-- Updated dependencies [e5c3f95]
-  - @llamaindex/openai@0.3.4
-  - llamaindex@0.10.2
-
 ## 0.2.12
 
 ### Patch Changes

apps/next/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llamaindex/doc",
-  "version": "0.2.18",
+  "version": "0.2.12",
   "private": true,
   "scripts": {
     "postinstall": "fumadocs-mdx",
@@ -15,7 +15,7 @@
   "dependencies": {
     "@huggingface/transformers": "^3.5.0",
     "@icons-pack/react-simple-icons": "^10.1.0",
-    "@llama-flow/docs": "0.0.8",
+    "@llama-flow/docs": "0.0.3",
     "@llamaindex/chat-ui": "0.2.0",
     "@llamaindex/cloud": "workspace:*",
     "@llamaindex/core": "workspace:*",
@@ -90,9 +90,9 @@
     "remark-stringify": "^11.0.0",
     "tailwindcss": "^4.0.9",
     "tsx": "^4.19.3",
-    "typedoc": "0.28.3",
+    "typedoc": "0.28.2",
     "typedoc-plugin-markdown": "^4.6.2",
-    "typedoc-plugin-merge-modules": " ^7.0.0",
+    "typedoc-plugin-merge-modules": "^7.0.0",
     "typescript": "^5.7.3"
   }
 }

apps/next/scripts/generate-docs.mts

@@ -1,3 +1,4 @@
+import { generateFiles as openapiGenerateFiles } from "fumadocs-openapi";
 import {
   createGenerator,
   generateFiles as typescriptGenerateFiles,
@@ -13,12 +14,18 @@ const apiRefOut = "./src/content/docs/api";
 // clean generated files
 rimrafSync(out, {
   filter(v) {
-    return !v.endsWith("index.md") && !v.endsWith("meta.json");
+    return !v.endsWith("index.mdx") && !v.endsWith("meta.json");
   },
 });
 
+void openapiGenerateFiles({
+  input: ["../../packages/cloud/openapi.json"],
+  output: "./src/content/docs/cloud/api",
+  groupBy: "tag",
+});
+
 void typescriptGenerateFiles(generator, {
-  input: ["./src/content/docs/api/**/*.md"],
+  input: ["./src/content/docs/api/**/*.mdx"],
   output: (file) => path.resolve(path.dirname(file), path.basename(file)),
   transformOutput,
 });
@@ -27,22 +34,19 @@ function transformOutput(filePath: string, content: string) {
   const fileName = path.basename(filePath);
   let title = fileName.split(".")[0];
   if (title === "index") title = "LlamaIndex API Reference";
-  return `---\ntitle: ${title}\n---\n\n${transformAbsoluteUrl(
-    content.replace(/(?<!\\)\{([^}]+)(?<!\\)}/g, "\\{$1\\}"),
-    filePath,
-  )}`;
+  return `---\ntitle: ${title}\n---\n\n${transformAbsoluteUrl(content, filePath)}`;
 }
 
 /**
- * Transforms the content by converting relative MD links to absolute docs API links
- * Example: [text](../type-aliases/TaskHandler.md) -> [text](/docs/api/type-aliases/TaskHandler)
- * [text](BaseChatEngine.md) -> [text](/docs/api/classes/BaseChatEngine)
- * [text](BaseVectorStore.md#constructors) -> [text](/docs/api/classes/BaseVectorStore#constructors)
- * [text](TaskStep.md) -> [text](/docs/api/type-aliases/TaskStep)
+ * Transforms the content by converting relative MDX links to absolute docs API links
+ * Example: [text](../type-aliases/TaskHandler.mdx) -> [text](/docs/api/type-aliases/TaskHandler)
+ * [text](BaseChatEngine.mdx) -> [text](/docs/api/classes/BaseChatEngine)
+ * [text](BaseVectorStore.mdx#constructors) -> [text](/docs/api/classes/BaseVectorStore#constructors)
+ * [text](TaskStep.mdx) -> [text](/docs/api/type-aliases/TaskStep)
  */
 function transformAbsoluteUrl(content: string, filePath: string) {
   const group = path.dirname(filePath).split(path.sep).pop();
-  return content.replace(/\]\(([^)]+)\.md([^)]*)\)/g, (_, slug, anchor) => {
+  return content.replace(/\]\(([^)]+)\.mdx([^)]*)\)/g, (_, slug, anchor) => {
     const slugParts = slug.split("/");
     const fileName = slugParts[slugParts.length - 1];
     const fileGroup = slugParts[slugParts.length - 2] ?? group;

apps/next/scripts/validate-links.mts

@@ -4,6 +4,7 @@ import matter from "gray-matter";
 import path from "path";
 
 const CONTENT_DIR = path.join(process.cwd(), "src/content/docs");
+const BUILD_DIR = path.join(process.cwd(), ".next");
 
 // Regular expression to find internal links
 // This captures Markdown links [text](/docs/path) and href attributes href="/docs/path"
@@ -13,8 +14,6 @@ const INTERNAL_LINK_REGEX = /(?:(?:\]\(|\bhref=["'])\/docs\/([^")]+))/g;
 // This captures relative links like [text](./path) or ![alt](../images/image.png)
 const RELATIVE_LINK_REGEX = /(?:\]\()(?:\s*)(?:\.\.?)\//g;
 
-const ALLOWED_LINKS = ["/docs/llamaflow"];
-
 interface LinkValidationResult {
   file: string;
   invalidLinks: Array<{ link: string; line: number }>;
@@ -29,14 +28,14 @@ interface RelativeLinkResult {
  * Get all valid documentation routes from the content directory
  */
 async function getValidRoutes(): Promise<Set<string>> {
-  const mdxFiles = await glob("**/*.{md,mdx}", { cwd: CONTENT_DIR });
+  const mdxFiles = await glob("**/*.mdx", { cwd: CONTENT_DIR });
 
   const routes = new Set<string>();
 
   // Add each MDX file as a valid route
   for (const file of mdxFiles) {
     // Remove .mdx extension and normalize to route format
-    let route = file.replace(/\.mdx?$/, "");
+    let route = file.replace(/\.mdx$/, "");
 
     // Handle index files
     if (route.endsWith("/index")) {
@@ -125,6 +124,9 @@ function findRelativeLinksInFile(
   return relativeLinks;
 }
 
+/**
+ * Validate internal links in all MDX files
+ */
 /**
  * Find relative links in all MDX files
  */
@@ -158,11 +160,6 @@ async function validateLinks(): Promise<LinkValidationResult[]> {
     const links = extractLinksFromFile(filePath);
 
     const invalidLinks = links.filter(({ link }) => {
-      // Check if the link is in the allowed list
-      if (ALLOWED_LINKS.includes(`/docs/${link}`)) {
-        return false;
-      }
-
       // Check if the link exists in valid routes
       // First normalize the link (remove any query string or hash)
       const baseLink = link.split("?")[0].split("#")[0];

apps/next/source.config.ts

@@ -1,10 +1,8 @@
-import {
-  rehypeCodeDefaultOptions,
-  remarkStructure,
-} from "fumadocs-core/mdx-plugins";
+import { rehypeCodeDefaultOptions } from "fumadocs-core/mdx-plugins";
 import { fileGenerator, remarkDocGen, remarkInstall } from "fumadocs-docgen";
 import { defineConfig, defineDocs } from "fumadocs-mdx/config";
 import { transformerTwoslash } from "fumadocs-twoslash";
+import { createFileSystemTypesCache } from "fumadocs-twoslash/cache-fs";
 import rehypeKatex from "rehype-katex";
 import remarkMath from "remark-math";
 
@@ -26,7 +24,11 @@ export default defineConfig({
       },
       transformers: [
         ...(rehypeCodeDefaultOptions.transformers ?? []),
-        transformerTwoslash(),
+        transformerTwoslash({
+          typesCache: createFileSystemTypesCache({
+            dir: ".next/cache/twoslash",
+          }),
+        }),
         {
           name: "transformers:remove-notation-escape",
           code(hast) {
@@ -47,7 +49,6 @@ export default defineConfig({
       ],
     },
     remarkPlugins: [
-      remarkStructure,
       remarkMath,
       [remarkInstall, { persist: { id: "package-manager" } }],
       [remarkDocGen, { generators: [fileGenerator()] }],

apps/next/src/app/(home)/page.tsx

@@ -26,7 +26,7 @@ const llm = openai();
 const response = await llm.chat({
   messages: [{ content: "Tell me a joke.", role: "user" }],
 });`,
-  `import { agent } from "@llamaindex/workflow";
+  `import { agent } from "llamaindex";
 import { openai } from "@llamaindex/openai";
 
 const analyseAgent = agent({
@@ -36,7 +36,7 @@ const analyseAgent = agent({
 });
 const response = await analyseAgent.run(\`Analyse the given data:
 \${data}\`);`,
-  `import { agent, multiAgent } from "@llamaindex/workflow";
+  `import { agent, multiAgent } from "llamaindex";
 import { openai } from "@llamaindex/openai";
 
 const analyseAgent = agent({
@@ -113,9 +113,8 @@ export default function HomePage() {
           description="Truly powerful retrieval-augmented generation applications use agentic techniques, and LlamaIndex.TS makes it easy to build them."
         >
           <CodeBlock
-            code={`import { SimpleDirectoryReader, VectorStoreIndex } from "llamaindex";
+            code={`import { agent, SimpleDirectoryReader, VectorStoreIndex } from "llamaindex";
 import { openai } from "@llamaindex/openai";
-import { agent } from "@llamaindex/workflow";
 
 // load documents from current directoy into an index
 const reader = new SimpleDirectoryReader();

apps/next/src/app/api/search/route.ts

@@ -4,7 +4,7 @@ import { createFromSource } from "fumadocs-core/search/server";
 
 // TODO: migrate to another search service, I don't think Vercel can handle that many of documents.
 export const { GET } = createFromSource(source, (page) => ({
-  id: page.file.path,
+  id: page.url,
   title: page.data.title,
   description: page.data.description,
   url: page.url,

apps/next/src/app/docs/layout.tsx

@@ -1,7 +1,11 @@
 import { baseOptions } from "@/app/layout.config";
+import { AITrigger } from "@/components/ai-chat";
+import { buttonVariants } from "@/components/ui/button";
 import { source } from "@/lib/source";
+import { cn } from "@/lib/utils";
 import "fumadocs-twoslash/twoslash.css";
 import { DocsLayout } from "fumadocs-ui/layouts/docs";
+import { MessageCircle } from "lucide-react";
 import type { ReactNode } from "react";
 
 export default function Layout({ children }: { children: ReactNode }) {
@@ -9,9 +13,23 @@ export default function Layout({ children }: { children: ReactNode }) {
     <DocsLayout
       tree={source.pageTree}
       {...baseOptions}
-      links={[]}
       nav={{
         ...baseOptions.nav,
+        children: (
+          <AITrigger
+            className={cn(
+              buttonVariants({
+                variant: "secondary",
+                size: "xs",
+                className:
+                  "text-fd-muted-foreground ms-2 gap-1.5 rounded-full px-2 md:flex-1",
+              }),
+            )}
+          >
+            <MessageCircle className="size-3" />
+            Ask LlamaCloud
+          </AITrigger>
+        ),
       }}
     >
       {children}

apps/next/src/app/layout.config.tsx

@@ -27,19 +27,9 @@ export const baseOptions: BaseLayoutProps = {
   githubUrl: "https://github.com/run-llama/LlamaIndexTS",
   links: [
     {
-      text: "TypeScript",
+      text: "Docs",
       url: DOCUMENT_URL,
       active: "nested-url",
     },
-    {
-      text: "Python",
-      url: "https://docs.llamaindex.ai",
-      active: "url",
-    },
-    {
-      text: "LlamaCloud",
-      url: "https://docs.cloud.llamaindex.ai/",
-      active: "url",
-    },
   ],
 };

apps/next/src/app/llms.txt/route.ts

@@ -13,7 +13,11 @@ import remarkStringify from "remark-stringify";
 export const revalidate = false;
 
 export async function GET() {
-  const files = await fg(["./src/content/docs/**/*.mdx"]);
+  const files = await fg([
+    "./src/content/docs/**/*.mdx",
+    // remove generated openapi files
+    "!./src/content/docs/cloud/api/**/*",
+  ]);
 
   const scan = files.map(async (file) => {
     const fileContent = await fs.readFile(file);

apps/next/src/components/demo/lazy.ts

@@ -11,3 +11,8 @@ export const CodeNodeParserDemo = dynamic(() =>
     (mod) => mod.CodeNodeParserDemo,
   ),
 );
+export const WorkflowStreamingDemo = dynamic(() =>
+  import("@/components/demo/workflow-streaming-ui").then(
+    (mod) => mod.WorkflowStreamingDemo,
+  ),
+);

apps/next/src/components/demo/workflow-streaming-ui.tsx

@@ -0,0 +1,152 @@
+"use client";
+import FlowInput from "@/components/flow-input";
+import { Button } from "@/components/ui/button";
+import {
+  StartEvent,
+  StopEvent,
+  Workflow,
+  WorkflowEvent,
+} from "@llamaindex/workflow";
+import { ReactNode, startTransition, useState } from "react";
+import { StickToBottom, useStickToBottomContext } from "use-stick-to-bottom";
+
+class ComputeEvent extends WorkflowEvent<number> {
+  constructor(data: number) {
+    super(data);
+  }
+}
+
+class ComputeResultEvent extends WorkflowEvent<number> {
+  constructor(data: number) {
+    super(data);
+  }
+}
+
+type ContextData = {
+  sum: number;
+};
+
+const workflow = new Workflow<ContextData, number, number>();
+
+const max = 1000;
+const min = 100;
+
+workflow.addStep(
+  {
+    inputs: [StartEvent<number>],
+    outputs: [StopEvent<number>],
+  },
+  async (context, event) => {
+    const total = event.data;
+    for (let i = 0; i < total; i++) {
+      context.sendEvent(new ComputeEvent(i));
+    }
+    console.log("waiting");
+    const computeResults = await Promise.all(
+      Array.from({ length: total }).map(() =>
+        context.requireEvent(ComputeResultEvent),
+      ),
+    );
+    context.data.sum = computeResults.reduce(
+      (acc, result) => acc + result.data,
+      0,
+    );
+    console.log("stop");
+    return new StopEvent(context.data.sum);
+  },
+);
+
+workflow.addStep(
+  {
+    inputs: [ComputeEvent],
+    outputs: [ComputeResultEvent],
+  },
+  async (context, event) => {
+    await new Promise((resolve) =>
+      setTimeout(resolve, Math.floor(Math.random() * (max - min + 1) + min)),
+    );
+    return new ComputeResultEvent(event.data);
+  },
+);
+
+function ScrollToBottom() {
+  const { isAtBottom, scrollToBottom } = useStickToBottomContext();
+
+  return (
+    !isAtBottom && (
+      <button
+        className="i-ph-arrow-circle-down-fill absolute bottom-0 left-[50%] translate-x-[-50%] rounded-lg text-4xl"
+        onClick={() => scrollToBottom()}
+      />
+    )
+  );
+}
+
+export function WorkflowStreamingDemo() {
+  const [ui, setUI] = useState<ReactNode[]>([
+    <div key={0} className="bg-gray-100 dark:bg-gray-800">
+      Waiting for workflow to start
+    </div>,
+  ]);
+  const [total, setTotal] = useState<number>(10);
+
+  return (
+    <div className="flex w-full flex-col items-start gap-2">
+      <div className="flex flex-row items-center justify-center">
+        <div className="mr-2 text-lg">Compute total</div>{" "}
+        <FlowInput value={total} onChange={(value) => setTotal(value)} />
+      </div>
+      <Button
+        onClick={async () => {
+          startTransition(() => {
+            setUI([]);
+          });
+          const context = workflow.run(total, {
+            sum: 0,
+          });
+          let i = 0;
+          for await (const event of context) {
+            console.log(event);
+            if (event instanceof ComputeEvent) {
+              setUI((ui) => [
+                ...ui,
+                <div key={i++} className="bg-yellow-100 dark:bg-yellow-800">
+                  Computing task id: {event.data}
+                </div>,
+              ]);
+            } else if (event instanceof ComputeResultEvent) {
+              setUI((ui) => [
+                ...ui,
+                <div key={i++} className="bg-green-100 dark:bg-green-800">
+                  Computed task id: {event.data}
+                </div>,
+              ]);
+            } else if (event instanceof StartEvent) {
+              setUI((ui) => [
+                ...ui,
+                <div key={i++} className="bg-blue-100 dark:bg-blue-800">
+                  Started workflow with total {event.data}
+                </div>,
+              ]);
+            } else if (event instanceof StopEvent) {
+              setUI((ui) => [
+                ...ui,
+                <div key={i++} className="bg-red-100 dark:bg-red-800">
+                  Workflow stopped
+                </div>,
+              ]);
+            }
+          }
+        }}
+      >
+        Start Workflow
+      </Button>
+      <StickToBottom className="flex max-h-96 w-full flex-col gap-2 overflow-y-auto rounded-lg border border-gray-200 p-2">
+        <StickToBottom.Content className="flex flex-col gap-2">
+          {ui}
+        </StickToBottom.Content>
+        <ScrollToBottom />
+      </StickToBottom>
+    </div>
+  );
+}

apps/next/src/content/docs/cloud/index.mdx

@@ -0,0 +1,8 @@
+---
+title: LlamaCloud
+description: 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.
+---
+
+This is TypeScript binding for LlamaCloud API. It provides a simple way to interact with LlamaCloud API.
+
+If you are looking for the official documentation, please visit the [Official Document](https://docs.cloud.llamaindex.ai/)

apps/next/src/content/docs/cloud/meta.json

@@ -0,0 +1,6 @@
+{
+  "title": "LlamaCloud",
+  "description": "The Cloud framework for LLM",
+  "root": true,
+  "pages": ["---Guide---", "index", "..."]
+}

apps/next/src/content/docs/llamaindex/getting_started/concepts.mdx

@@ -1,60 +0,0 @@
----
-title: High-Level Concepts
----
-
-This is a quick guide to the high-level concepts you'll encounter frequently when building LLM applications.
-
-## Large Language Models (LLMs)
-
-LLMs are the fundamental innovation that launched LlamaIndex. They are an artificial intelligence (AI) computer system that can understand, generate, and manipulate natural language, including answering questions based on their training data or data provided to them at query time. 
-
-## Agentic Applications
-
-When an LLM is used within an application, it is often used to make decisions, take actions, and/or interact with the world. This is the core definition of an **agentic application**.
-
-While the definition of an agentic application is broad, there are several key characteristics that define an agentic application:
-
-- **LLM Augmentation**: The LLM is augmented with tools (i.e. arbitrary callable functions in code), memory, and/or dynamic prompts.
-- **Prompt Chaining**: Several LLM calls are used that build on each other, with the output of one LLM call being used as the input to the next.
-- **Routing**: The LLM is used to route the application to the next appropriate step or state in the application.
-- **Parallelism**: The application can perform multiple steps or actions in parallel.
-- **Orchestration**: A hierarchical structure of LLMs is used to orchestrate lower-level actions and LLMs.
-- **Reflection**: The LLM is used to reflect and validate outputs of previous steps or LLM calls, which can be used to guide the application to the next appropriate step or state.
-
-In LlamaIndex, you can build agentic applications by using the workflows to orchestrate a sequence of steps and LLMs. You can [learn more about workflows](/docs/llamaindex/tutorials/workflows).
-
-## Agents
-
-We define an agent as a specific instance of an "agentic application". An agent is a piece of software that semi-autonomously performs tasks by combining LLMs with other tools and memory, orchestrated in a reasoning loop that decides which tool to use next (if any).
-
-What this means in practice, is something like:
-- An agent receives a user message
-- The agent uses an LLM to determine the next appropriate action to take using the previous chat history, tools, and the latest user message
-- The agent may invoke one or more tools to assist in the users request
-- If tools are used, the agent will then interpret the tool outputs and use them to inform the next action
-- Once the agent stops taking actions, it returns the final output to the user
-
-You can [learn more about agents](/docs/llamaindex/tutorials/basic_agent).
-
-## Retrieval Augmented Generation (RAG)
-
-Retrieval-Augmented Generation (RAG) is a core technique for building data-backed LLM applications with LlamaIndex. It allows LLMs to answer questions about your private data by providing it to the LLM at query time, rather than training the LLM on your data. To avoid sending **all** of your data to the LLM every time, RAG indexes your data and selectively sends only the relevant parts along with your query. You can [learn more about RAG](/docs/llamaindex/tutorials/rag).
-
-## Use cases
-
-There are endless use cases for data-backed LLM applications but they can be roughly grouped into four categories:
-
-[**Agents**](/docs/llamaindex/tutorials/basic_agent):
-An agent is an automated decision-maker powered by an LLM that interacts with the world via a set of [tools](/docs/llamaindex/modules/agents/tool). Agents can take an arbitrary number of steps to complete a given task, dynamically deciding on the best course of action rather than following pre-determined steps. This gives it additional flexibility to tackle more complex tasks.
-
-[**Workflows**](/docs/llamaindex/tutorials/workflows):
-A Workflow in LlamaIndex is a specific event-driven abstraction that allows you to orchestrate a sequence of steps and LLMs calls. Workflows can be used to implement any agentic application, and are a core component of LlamaIndex.
-
-[**Structured Data Extraction**](/docs/llamaindex/tutorials/structured_data_extraction):
-Pydantic extractors allow you to specify a precise data structure to extract from your data and use LLMs to fill in the missing pieces in a type-safe way. This is useful for extracting structured data from unstructured sources like PDFs, websites, and more, and is key to automating workflows.
-
-[**Query Engines**](/docs/llamaindex/modules/rag/query_engines):
-A query engine is an end-to-end flow that allows you to ask questions 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/rag/chat_engine):
-A chat engine is an end-to-end flow for having a conversation with your data (multiple back-and-forth instead of a single question-and-answer).

apps/next/src/content/docs/llamaindex/getting_started/installation/index.mdx

@@ -9,10 +9,10 @@ To install llamaindex, run the following command:
 npm i llamaindex
 ```
 
-In most cases, you'll also need an LLM package and the Workflow package to use LlamaIndex. For example, to use the OpenAI LLM with agents, you would install the following:
+In most cases, you'll also need an LLM package to use LlamaIndex. For example, to use the OpenAI LLM, you would install the following:
 
 ```package-install
-npm i @llamaindex/openai @llamaindex/workflow
+npm i @llamaindex/openai
 ```
 
 Go to [LLM APIs](/docs/llamaindex/modules/models/llms) to find out how to use other LLMs.

apps/next/src/content/docs/llamaindex/getting_started/installation/typescript.mdx

@@ -40,7 +40,19 @@ Make sure to set [moduleResolution](https://www.typescriptlang.org/docs/handbook
 }
 ```
 
-We recommend using `bundler` or `nodenext`, but due to popularity of `node`, we still added support for it.
+We recommend using `bundler` or `nodenext`, but due to popularity of `node`, we still added support for it, but with import path limitations.
+
+So you may encounter type errors when importing sub paths from the `llamaindex` package like:
+
+```ts
+import { Settings } from "llamaindex";
+```
+
+The simplest way to fix this without changing `moduleResolution` is to import directly from `llamaindex`:
+
+```ts
+import { Settings } from "llamaindex";
+```
 
 ## Enable AsyncIterable for `Web Stream` API
 
@@ -56,8 +68,7 @@ Some modules uses `Web Stream` API like `ReadableStream` and `WritableStream`, y
 ```
 
 ```typescript
-import { tool } from 'llamaindex'
-import { agent } from "@llamaindex/workflow";
+import { agent, tool } from 'llamaindex'
 import { openai } from "@llamaindex/openai";
 
 Settings.llm = openai({

apps/next/src/content/docs/llamaindex/getting_started/meta.json

@@ -1,4 +1,4 @@
 {
   "title": "Getting Started",
-  "pages": ["concepts", "installation", "create_llama", "examples"]
+  "pages": ["installation", "create_llama", "examples"]
 }

apps/next/src/content/docs/llamaindex/modules/agents/agent_workflow.mdx

@@ -12,8 +12,7 @@ Agent Workflows are a powerful system that enables you to create and orchestrate
 The simplest use case is creating a single agent with specific tools. Here's an example of creating an assistant that tells jokes:
 
 ```typescript
-import { tool } from "llamaindex";
-import { agent } from "@llamaindex/workflow";
+import { agent, tool } from "llamaindex";
 import { openai } from "@llamaindex/openai";
 
 // Define a joke-telling tool
@@ -41,17 +40,17 @@ console.log(result); // Baby Llama is called cria
 Agent Workflows provide a unified interface for event streaming, making it easy to track and respond to different events during execution:
 
 ```typescript
-import { agentToolCallEvent, agentStreamEvent } from "@llamaindex/workflow";
+import { AgentToolCall, AgentStream } from "llamaindex";
 
 // Get the workflow execution context
-const events = workflow.runStream("Tell me something funny");
+const context = workflow.run("Tell me something funny");
 
 // Stream and handle events
-for await (const event of events) {
-  if (agentToolCallEvent.include(event)) {
+for await (const event of context) {
+  if (event instanceof AgentToolCall) {
     console.log(`Tool being called: ${event.data.toolName}`);
   }
-  if (agentStreamEvent.include(event)) {
+  if (event instanceof AgentStream) {
     process.stdout.write(event.data.delta);
   }
 }
@@ -69,8 +68,7 @@ An Agent Workflow can orchestrate multiple agents, enabling complex interactions
 Here's an example of a multi-agent system that combines joke-telling and weather information:
 
 ```typescript
-import { tool } from "llamaindex";
-import { multiAgent, agent } from "@llamaindex/workflow";
+import { multiAgent, agent, tool } from "llamaindex";
 import { openai } from "@llamaindex/openai";
 import { z } from "zod";
 

apps/next/src/content/docs/llamaindex/modules/agents/tool/index.mdx

@@ -17,8 +17,7 @@ The `parameters` field in the tool configuration is defined using `zod`, a TypeS
 
 Example:
 ```ts
-import { tool } from "llamaindex";
-import { agent } from "@llamaindex/workflow";
+import { agent, tool } from "llamaindex";
 import { z } from "zod";
 
 // first arg is LLM input, second is bound arg
@@ -47,7 +46,7 @@ In this example, `z.object` is used to define a schema for the `parameters` wher
 You can import built-in tools from the `@llamaindex/tools` package.
 
 ```ts
-import { agent } from "@llamaindex/workflow";
+import { agent } from "llamaindex";
 import { wiki } from "@llamaindex/tools";
 
 const researchAgent = agent({
@@ -58,41 +57,6 @@ const researchAgent = agent({
 });
 ```
 
-## MCP tools
-
-If you have a MCP server running, you can fetch tools from the server and use them in your agents.
-
-```ts
-// 1. Import MCP tools adapter
-import { mcp } from "@llamaindex/tools";
-import { agent } from "@llamaindex/workflow";
-
-// 2. Initialize a MCP client
-// by npx
-const server = mcp({
-  command: "npx",
-  args: ["-y", "@modelcontextprotocol/server-filesystem", "."],
-  verbose: true,
-});
-// or by SSE
-const server = mcp({
-  url: "http://localhost:8000/mcp",
-  verbose: true,
-});
-
-// 3. Get tools from MCP server
-const tools = await server.tools();
-
-// Now you can create an agent with the tools
-const agent = agent({
-  name: "My Agent",
-  systemPrompt: "You are a helpful assistant that can use the provided tools to answer questions.",
-  llm: openai({ model: "gpt-4o" }),
-  tools: tools,
-});
-```
-
-
 ## Function tool
 
 You can still use the `FunctionTool` class to define a tool.
@@ -115,8 +79,7 @@ Note: calling the `bind` method will return a new `FunctionTool` instance, witho
 
 Example to pass a `userToken` as additional argument:
 ```ts
-import { tool } from "llamaindex";
-import { agent } from "@llamaindex/workflow";
+import { agent, tool } from "llamaindex";
 
 // first arg is LLM input, second is bound arg
 const queryKnowledgeBase = async ({ question }, { userToken }) => {

apps/next/src/content/docs/llamaindex/modules/agents/workflows.mdx

@@ -2,17 +2,149 @@
 title: Workflows
 ---
 
-A `Workflow` in LlamaIndex is a lightweight, event-driven abstraction used to chain together several events. Workflows are made up of `handlers`, with each one responsible for processing specific event types and emitting new events.
+A `Workflow` in LlamaIndexTS is an event-driven abstraction used to chain together several events. Workflows are made up of `steps`, with each step responsible for handling certain event types and emitting new events.
 
-Workflows are designed to be flexible and can be used to build agents, RAG flows, extraction flows, or anything else you want to implement.
+Workflows in LlamaIndexTS work by defining step functions that handle specific event types and emit new events.
+
+When a step function is added to a workflow, you need to specify the input and optionally the output event types (used for validation). The specification of the input events ensures each step only runs when an accepted event is ready.
+
+You can create a `Workflow` to do anything! Build an agent, a RAG flow, an extraction flow, or anything else you want.
 
-To use workflows install this package:
 
 ```package-install
 npm i @llamaindex/workflow
 ```
 
-This package is a stable, production-ready version of our [llama-flow](/docs/llamaflow) project. 
+## Getting Started
 
-While you can still reference the llama-flow documentation for detailed information about the underlying concepts, we recommend using the `@llamaindex/workflow` package for all new projects to ensure stability and long-term availability.
+As an illustrative example, let's consider a naive workflow where a joke is generated and then critiqued.
 
+<include cwd>../../examples/workflow/joke.ts</include>
+
+There's a few moving pieces here, so let's go through this piece by piece.
+
+### Defining Workflow Events
+
+```typescript
+export class JokeEvent extends WorkflowEvent<{ joke: string }> {}
+```
+
+Events are user-defined classes that extend `WorkflowEvent` and contain arbitrary data provided as template argument. In this case, our workflow relies on a single user-defined event, the `JokeEvent` with a `joke` attribute of type `string`.
+
+### Setting up the Workflow Class
+
+```typescript
+const llm = new OpenAI();
+...
+const jokeFlow = new Workflow<unknown, string, string>();
+```
+
+Our workflow is implemented by initiating the `Workflow` class with three generic types: the context type (unknown), input type (string), and output type (string). The context type is `unknown`, as we're not using a shared context in this example.
+
+For simplicity, we created an `OpenAI` llm instance that we're using for inference in our workflow.
+
+### Workflow Entry Points
+
+```typescript
+const generateJoke = async (_: unknown, ev: StartEvent<string>) => {
+  const prompt = `Write your best joke about ${ev.data}.`;
+  const response = await llm.complete({ prompt });
+  return new JokeEvent({ joke: response.text });
+};
+```
+
+Here, we come to the entry-point of our workflow. While events are user-defined, there are two special-case events, the `StartEvent` and the `StopEvent`. These events are predefined, but we can specify the payload type using generic types. We're using `StartEvent<string>` to indicate that we're going to send an input of type string.
+
+To add this step to the workflow, we use the `addStep` method with an object specifying the input and output event types:
+
+```typescript
+jokeFlow.addStep(
+  {
+    inputs: [StartEvent<string>],
+    outputs: [JokeEvent],
+  },
+  generateJoke
+);
+```
+
+### Workflow Exit Points
+
+```typescript
+const critiqueJoke = async (_: unknown, ev: JokeEvent) => {
+  const prompt = `Give a thorough critique of the following joke: ${ev.data.joke}`;
+  const response = await llm.complete({ prompt });
+  return new StopEvent(response.text);
+};
+```
+
+Here, we have our second and last step in the workflow. We know it's the last step because the special `StopEvent` is returned. When the workflow encounters a returned `StopEvent`, it immediately stops the workflow and returns the result. Note that we're using the generic type `StopEvent<string>` to indicate that we're returning a string.
+
+Add this step to the workflow:
+
+```typescript
+jokeFlow.addStep(
+  {
+    inputs: [JokeEvent],
+    outputs: [StopEvent<string>],
+  },
+  critiqueJoke
+);
+```
+
+### Running the Workflow
+
+```typescript
+const result = await jokeFlow.run("pirates");
+console.log(result.data.result);
+```
+
+Lastly, we run the workflow. The `.run()` method is async, so we use await here to wait for the result.
+
+## Working with Shared Context/State
+
+Optionally, you can choose to use a shared context between steps by specifying a context type when creating the workflow. Here's an example where multiple steps access a shared state:
+
+```typescript
+import { HandlerContext } from "llamaindex";
+
+type MyContextData = {
+  query: string;
+  intermediateResults: any[];
+}
+
+const query = async (context: HandlerContext<MyContextData>, ev: MyEvent) => {
+  // get the query from the context
+  const query = context.data.query;
+  // do something with context and event
+  const val = ...
+  // store in context
+  context.data.intermediateResults.push(val);
+
+  return new StopEvent({ result });
+};
+```
+
+## Waiting for Multiple Events
+
+The context does more than just hold data, it also provides utilities to buffer and wait for multiple events.
+
+For example, you might have a step that waits for a query and retrieved nodes before synthesizing a response:
+
+```typescript
+const synthesize = async (context: Context, ev1: QueryEvent, ev2: RetrieveEvent) => {
+  const subPrompts = [`Answer this query using the context provided: ${ev1.data.query}`, `Context: ${ev2.data.context}`];
+  const prompt = subPrompts.join("\n");
+  const response = await llm.complete({ prompt });
+  return new StopEvent({ result: response.text });
+};
+```
+
+Passing multiple events, we can buffer and wait for ALL expected events to arrive. The receiving step function will only be called once all events have arrived.
+
+## Manually Triggering Events
+
+Normally, events are triggered by returning another event during a step. However, events can also be manually dispatched using the `ctx.sendEvent(event)` method within a workflow.
+
+## Examples
+
+You can find many useful examples of using workflows in the [examples folder](https://github.com/run-llama/LlamaIndexTS/blob/main/examples/workflow).

apps/next/src/content/docs/llamaindex/modules/data/readers/discord.mdx

@@ -5,12 +5,6 @@ title: 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.
 
-## Installation
-
-```package-install
-npm install @llamaindex/discord
-```
-
 ## Usage
 
 First step is to create a Discord Application and generating a bot token [here](https://discord.com/developers/applications).
@@ -18,7 +12,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.
 
-<include cwd>../../examples/readers/discord/reader.ts</include>
+<include cwd>../../examples/readers/src/discord.ts</include>
 
 ### Params
 

apps/next/src/content/docs/llamaindex/modules/data/readers/index.mdx

@@ -21,18 +21,27 @@ To install readers call:
 
 We offer readers for different file formats.
 
-```ts twoslash
-import { CSVReader } from '@llamaindex/readers/csv';
-import { DocxReader } from '@llamaindex/readers/docx';
-import { HTMLReader } from '@llamaindex/readers/html';
-import { ImageReader } from '@llamaindex/readers/image';
-import { JSONReader } from '@llamaindex/readers/json';
-import { MarkdownReader } from '@llamaindex/readers/markdown';
-import { ObsidianReader } from '@llamaindex/readers/obsidian';
-import { PDFReader } from '@llamaindex/readers/pdf';
-import { TextFileReader } from '@llamaindex/readers/text';
+```ts twoslash 
+import { CSVReader } from '@llamaindex/readers/csv'
+import { PDFReader } from '@llamaindex/readers/pdf'
+import { JSONReader } from '@llamaindex/readers/json'
+import { MarkdownReader } from '@llamaindex/readers/markdown'
+import { HTMLReader } from '@llamaindex/readers/html'
+// you can find more readers in the documentation
 ```
 
+Additionally the following loaders exist without separate documentation:
+
+- `AssemblyAIReader` transcribes audio using [AssemblyAI](https://www.assemblyai.com/).
+  - [AudioTranscriptReader](/docs/api/classes/AudioTranscriptReader): loads entire transcript as a single document.
+  - [AudioTranscriptParagraphsReader](/docs/api/classes/AudioTranscriptParagraphsReader): creates a document per paragraph.
+  - [AudioTranscriptSentencesReader](/docs/api/classes/AudioTranscriptSentencesReader): creates a document per sentence.
+  - [AudioSubtitlesReader](/docs/api/classes/AudioTranscriptParagraphsReader): creates a document containing the subtitles of a transcript.
+- [NotionReader](/docs/api/classes/NotionReader) loads [Notion](https://www.notion.so/) pages.
+- [SimpleMongoReader](/docs/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://stackblitz.com/github/run-llama/LlamaIndexTS/tree/main/examples/readers?file=src/simple-directory-reader.ts&title=Simple%20Directory%20Reader)

apps/next/src/content/docs/llamaindex/modules/data/readers/llama_parse/images.mdx

@@ -112,3 +112,6 @@ The returned `imageDocs` have the alt text assigned as text and the image path a
 
 You can see the full example file [here](https://github.com/run-llama/LlamaIndexTS/blob/main/examples/readers/src/llamaparse-json.ts).
 
+## API Reference
+
+- [LlamaParseReader](/docs/api/classes/LlamaParseReader)

apps/next/src/content/docs/llamaindex/modules/data/readers/llama_parse/index.mdx

@@ -32,7 +32,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`.
+- `language` primarily helps with OCR recognition. Defaults to `en`. Click [here](/docs/api/type-aliases/Language) 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`.
@@ -61,3 +61,4 @@ Below a full example of `LlamaParse` integrated in `SimpleDirectoryReader` with
 ## API Reference
 
 - [SimpleDirectoryReader](/docs/api/classes/SimpleDirectoryReader)
+- [LlamaParseReader](/docs/api/classes/LlamaParseReader)

apps/next/src/content/docs/llamaindex/modules/data/readers/llama_parse/json_mode.mdx

@@ -98,4 +98,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)

apps/next/src/content/docs/llamaindex/modules/data/stores/vector_stores/qdrant.mdx

@@ -88,7 +88,7 @@ async function main() {
 
   const response = await queryEngine.query({
     query: "What did the author do in college?",
-  }); // Additional filters and params can be passed as options
+  });
 
   // Output response
   console.log(response.toString());

apps/next/src/content/docs/llamaindex/modules/models/llms/bedrock.mdx

@@ -120,11 +120,11 @@ async function main() {
 
 ```ts
 import { BEDROCK_MODELS, Bedrock } from "@llamaindex/community";
-import { tool } from "llamaindex";
-import { agent } from "@llamaindex/workflow";
+import { FunctionTool, LLMAgent } from "llamaindex";
 import { z } from "zod";
 
-const sumNumbers = tool(
+const sumNumbers = FunctionTool.from(
+  ({ a, b }: { a: number; b: number }) => `${a + b}`,
   {
     name: "sumNumbers",
     description: "Use this function to sum two numbers",
@@ -136,11 +136,11 @@ const sumNumbers = tool(
         description: "The second number",
       }),
     }),
-    execute: ({ a, b }: { a: number; b: number }) => `${a + b}`,
   },
 );
 
-const divideNumbers = tool(
+const divideNumbers = FunctionTool.from(
+  ({ a, b }: { a: number; b: number }) => `${a / b}`,
   {
     name: "divideNumbers",
     description: "Use this function to divide two numbers",
@@ -152,7 +152,6 @@ const divideNumbers = tool(
         description: "The divisor b to divide by",
       }),
     }),
-    execute: ({ a, b }: { a: number; b: number }) => `${a / b}`,
   },
 );
 
@@ -162,15 +161,15 @@ const bedrock = new Bedrock({
 });
 
 async function main() {
-  const myAgent = agent({
+  const agent = new LLMAgent({
     llm: bedrock,
     tools: [sumNumbers, divideNumbers],
   });
 
-  const response = await myAgent.run(
-    "How much is 5 + 5? then divide by 2",
-  );
+  const response = await agent.chat({
+    message: "How much is 5 + 5? then divide by 2",
+  });
 
-  console.log(response);
+  console.log(response.message);
 }
 ```

apps/next/src/content/docs/llamaindex/modules/models/llms/groq.mdx

@@ -55,7 +55,7 @@ const results = await queryEngine.query({
 
 ## Full Example
 
-<include cwd>../../examples/models/groq.ts</include>
+<include cwd>../../examples/groq.ts</include>
 
 ## API Reference
 

apps/next/src/content/docs/llamaindex/modules/ui/llamaindex-server.mdx

@@ -22,7 +22,7 @@ npm i @llamaindex/server
 
 ## Quick Start
 
-Create an `index.ts` file and add the following code:
+Create index.ts file and add the following code:
 
 ```ts
 import { LlamaIndexServer } from "@llamaindex/server";
@@ -43,20 +43,20 @@ new LlamaIndexServer({
 
 In the same directory as `index.ts`, run the following command to start the server:
 
-```bash
-tsx index.ts
-```
+  ```bash
+  tsx index.ts
+  ```
 The server will start at `http://localhost:3000`
 
 You can also make a request to the server:
 
-```bash
-curl -X POST "http://localhost:3000/api/chat" -H "Content-Type: application/json" -d '{"message": "Who is the first president of the United States?"}'
-```
+  ```bash
+  curl -X POST "http://localhost:3000/api/chat" -H "Content-Type: application/json" -d '{"message": "Who is the first president of the United States?"}'
+  ```
 
 ## Configuration Options
 
-The `LlamaIndexServer` accepts the following configuration options:
+The LlamaIndexServer accepts the following configuration
 
 - `workflow`: A callable function that creates a workflow instance for each request
 - `uiConfig`: An object to configure the chat UI containing the following properties:
@@ -68,72 +68,6 @@ The `LlamaIndexServer` accepts the following configuration options:
 LlamaIndexServer accepts all the configuration options from Nextjs Custom Server such as `port`, `hostname`, `dev`, etc.
 See all Nextjs Custom Server options [here](https://nextjs.org/docs/app/building-your-application/configuring/custom-server).
 
-## AI-generated UI Components
-
-The LlamaIndex server provides support for rendering workflow events using custom UI components, allowing you to extend and customize the chat interface. 
-These components can be auto-generated using an LLM by providing a JSON schema of the workflow event. 
-
-### UI Event Schema 
-
-To display custom UI components, your workflow needs to emit UI events that have an event type for identification and a data object:
-
-```typescript
-class UIEvent extends WorkflowEvent<{
-  type: "ui_event";
-  data: UIEventData;
-}> {}
-```
-
-The `data` object can be any JSON object. To enable AI generation of the UI component, you need to provide a schema for that data (here we're using Zod):
-
-```typescript
-const MyEventDataSchema = z.object({
-  stage: z.enum(["retrieve", "analyze", "answer"]).describe("The current stage the workflow process is in."),
-  progress: z.number().min(0).max(1).describe("The progress in percent of the current stage"),
-}).describe("WorkflowStageProgress");
-
-type UIEventData = z.infer<typeof MyEventDataSchema>;
-```
-
-### Generate UI Components
-
-The `generateEventComponent` function uses an LLM to generate a custom UI component based on the JSON schema of a workflow event. The schema should contain accurate descriptions of each field so that the LLM can generate matching components for your use case. We've done this for you in the example above using the `describe` function from Zod:
-
-```typescript
-import { OpenAI } from "llamaindex";
-import { generateEventComponent } from "@llamaindex/server";
-import { MyEventDataSchema } from "./your-workflow";
-
-// Also works well with Claude 3.5 Sonnet and Google Gemini 2.5 Pro
-const llm = new OpenAI({ model: "gpt-4.1" });
-const code = generateEventComponent(MyEventDataSchema, llm);
-```
-
-After generating the code, we need to save it to a file. The file name must match the event type from your workflow (e.g., `ui_event.jsx` for handling events with `ui_event` type):
-
-```ts
-fs.writeFileSync("components/ui_event.jsx", code);
-```
-
-Feel free to modify the generated code to match your needs. If you're not satisfied with the generated code, we suggest improving the provided JSON schema first or trying another LLM.
-
-> Note that `generateEventComponent` is generating JSX code, but you can also provide a TSX file.
-
-
-### Server Setup
-
-To use the generated UI components, you need to initialize the LlamaIndex server with the `componentsDir` that contains your custom UI components:
-
-```ts
-new LlamaIndexServer({
-  workflow: createWorkflow,
-  uiConfig: {
-    appTitle: "LlamaIndex App",
-    componentsDir: "components",
-  },
-}).start();
-```
-
 ## Default Endpoints and Features
 
 ### Chat Endpoint
@@ -151,19 +85,69 @@ The server always provides a chat interface at the root path (`/`) with:
 ### Static File Serving
 
 - The server automatically mounts the `data` and `output` folders at `{server_url}{api_prefix}/files/data` (default: `/api/files/data`) and `{server_url}{api_prefix}/files/output` (default: `/api/files/output`) respectively.
-- Your workflows can use both folders to store and access files. By convention, the `data` folder is used for documents that are ingested, and the `output` folder is used for documents generated by the workflow.
+- Your workflows can use both folders to store and access files. As a convention, the `data` folder is used for documents that are ingested and the `output` folder is used for documents that are generated by the workflow.
 
 
+## Custom UI Components
+
+The LlamaIndex server provides support for rendering workflow events using custom UI components, allowing you to extend and customize the chat interface.
+
+### Overview
+
+Custom UI components are a powerful feature that enables you to:
+
+- Add custom interface elements to the chat UI using React JSX or TSX files
+- Extend the default chat interface functionality
+- Create specialized visualizations or interactions
+
+### Configuration
+
+Your workflow must emit events that fit this structure, allowing the LlamaIndex server to display the right UI components based on the event type.
+
+```json
+{
+    "type": "<event_name>",
+    "data": <data model>
+}
+```
+
+### Server Setup
+
+1. Initialize the LlamaIndex server with a component directory:
+
+```ts
+new LlamaIndexServer({
+  workflow: createWorkflow,
+  uiConfig: {
+    appTitle: "LlamaIndex App",
+    componentsDir: "components",
+  },
+}).start();
+```
+
+2. Add the custom component code to the directory following the naming pattern:
+
+   - File Extension: `.jsx` and `.tsx` for React components
+   - File Name: Should match the event type from your workflow (e.g., `deep_research_event.jsx` for handling `deep_research_event` type that you defined in your workflow). If there are TSX and JSX files with the same name, the TSX file will be used.
+   - Component Name: Export a default React component named `Component` that receives props from the event data
+
+   Example component structure:
+
+   ```jsx
+   function Component({ events }) {
+       // Your component logic here
+       return (
+           // Your UI code here
+       );
+   }
+   ```
+
 ## Best Practices
 
-1. Always provide a workflow factory that creates a fresh workflow instance for each request.
-2. Use environment variables for sensitive configuration (e.g., API keys).
-3. Use starter questions to guide users in the chat UI.
+1. Always provide a workflow factory that creates fresh workflow instances
+2. Use environment variables for sensitive configuration
+3. Use starter questions to guide users in the chat UI
 
 ## Getting Started with a New Project
 
-Want to start a new project with LlamaIndexServer? Check out our [create-llama](https://github.com/run-llama/create-llama) tool to quickly generate a new project with LlamaIndexServer.
-
-## API Reference
-
-- [LlamaIndexServer](https://github.com/run-llama/create-llama/blob/main/packages/server)
+Want to start a new project with LlamaIndexServer? Check out our [create-llama](https://github.com/run-llama/create-llama) tool to quickly generate a new project with LlamaIndexServer.

apps/next/src/content/docs/llamaindex/tutorials/agents/1_setup.mdx

@@ -15,7 +15,7 @@ In LlamaIndex, an agent is a semi-autonomous piece of software powered by an LLM
 You'll need to have a recent version of [Node.js](https://nodejs.org/en) installed. Then you can install LlamaIndex.TS by running
 
 ```package-install
-npm i llamaindex @llamaindex/openai @llamaindex/readers @llamaindex/huggingface @llamaindex/workflow
+npm i llamaindex @llamaindex/openai @llamaindex/readers @llamaindex/huggingface
 ```
 
 ## Choose your model

apps/next/src/content/docs/llamaindex/tutorials/agents/2_create_agent.mdx

@@ -35,16 +35,11 @@ First we'll need to pull in our dependencies. These are:
 import "dotenv/config";
 import {
   agent,
-  agentStreamEvent,
-  openai,
-} from "@llamaindex/workflow";
-import {
+  AgentStream,
   tool,
+  openai,
   Settings,
 } from "llamaindex";
-import {
-  openai,
-} from "@llamaindex/openai";
 import { z } from "zod";
 ```
 
@@ -113,10 +108,11 @@ const myAgent = agent({ tools });
 
 ### Ask the agent a question
 
-We can use the `run` method to ask our agent a question, and it will use the tools we've defined to find an answer.
+We can use the `chat` interface to ask our agent a question, and it will use the tools we've defined to find an answer.
 
 ```javascript
-const result = await myAgent.run("Sum 101 and 303");
+const context = myAgent.run("Sum 101 and 303");
+const result = await context;
 console.log(result.data);
 ```
 You will see the following output:
@@ -127,13 +123,12 @@ You will see the following output:
 { result: 'The sum of 101 and 303 is 404.' }
 ```
 
-To stream the response, you need to call `runStream`, which returns a stream of events. 
-The `agentStreamEvent` provides chunks of the response as they become available. This allows you to display the response incrementally rather than waiting for the full response:
+To stream the response, you can use the `AgentStream` event which provides chunks of the response as they become available. This allows you to display the response incrementally rather than waiting for the full response:
 
 ```javascript
-const events = myAgent.runStream("Add 101 and 303");
-for await (const event of events) {
-  if (agentStreamEvent.include(event)) {
+const context = myAgent.run("Add 101 and 303");
+for await (const event of context) {
+  if (event instanceof AgentStream) {
     process.stdout.write(event.data.delta);
   }
 }
@@ -145,18 +140,18 @@ for await (const event of events) {
 The sum of 101 and 303 is 404.
 ```
 
-Note that we're filtering for `agentStreamEvent` as an agent might return other events - more about that in the following section.
-
 ### Logging workflow events
 
 To log the workflow events, you can check the event type and log the event data.
 
 ```javascript
-const events = myAgent.runStream("Sum 202 and 404");
-for await (const event of events) {
-  if (agentStreamEvent.include(event)) {
+const context = myAgent.run("Sum 202 and 404");
+for await (const event of context) {
+  if (event instanceof AgentStream) {
     // Stream the response
-    process.stdout.write(event.data.delta);
+    for (const chunk of event.data.delta) {
+      process.stdout.write(chunk);
+    }
   } else {
     // Log other events
     console.log("\nWorkflow event:", JSON.stringify(event, null, 2));

apps/next/src/content/docs/llamaindex/tutorials/agents/3_local_model.mdx

@@ -30,16 +30,16 @@ Settings.llm = ollama({
 
 ### Run local agent
 
-You can also create local agent by importing `agent` from `@llamaindex/workflow`.
+You can also create local agent by importing `agent` from `llamaindex`.
 
 ```javascript
-import { agent } from "@llamaindex/workflow";
+import { agent } from "llamaindex";
 
 const workflow = agent({
   tools: [getWeatherTool],
 });
 
-const resutl = workflow.run(
+const workflowContext = workflow.run(
   "What's the weather like in San Francisco?",
 );
 ```

apps/next/src/content/docs/llamaindex/tutorials/agents/4_agentic_rag.mdx

@@ -25,8 +25,7 @@ We'll be bringing in `SimpleDirectoryReader`, `HuggingFaceEmbedding`, `VectorSto
 
 ```javascript
 import { QueryEngineTool, Settings, VectorStoreIndex } from "llamaindex";
-import { agent } from "@llamaindex/workflow";
-import { openai } from "@llamaindex/openai";
+import { OpenAI, OpenAIAgent } from "@llamaindex/openai";
 import { HuggingFaceEmbedding } from "@llamaindex/huggingface";
 import { SimpleDirectoryReader } from "@llamaindex/readers/directory";
 ```
@@ -59,9 +58,25 @@ We will convert our text into embeddings using the `VectorStoreIndex` class thro
 const index = await VectorStoreIndex.fromDocuments(documents);
 ```
 
+### Configure a retriever
+
+Before LlamaIndex can send a query to the LLM, it needs to find the most relevant chunks to send. That's the purpose of a `Retriever`. We're going to get `VectorStoreIndex` to act as a retriever for us
+
+```javascript
+const retriever = await index.asRetriever();
+```
+
+### Configure how many documents to retrieve
+
+By default LlamaIndex will retrieve just the 2 most relevant chunks of text. This document is complex though, so we'll ask for more context.
+
+```javascript
+retriever.similarityTopK = 10;
+```
+
 ### Use index.queryTool
 
-`index.queryTool` creates a `QueryEngineTool` that can be used be an agent to query data from the index:
+`index.queryTool` creates a `QueryEngineTool` that can be used be an agent to query data from the index. 
 
 ```javascript
 const tools = [
@@ -70,17 +85,9 @@ const tools = [
       name: "san_francisco_budget_tool",
       description: `This tool can answer detailed questions about the individual components of the budget of San Francisco in 2023-2024.`,
     },
-    options: { similarityTopK: 10 },
   }),
 ];
-```
 
-The `metadata` that we're setting helps the agent to decide when to use the tool.
-Note that by default LlamaIndex will retrieve just the 2 most relevant chunks of text. This document is complex though, so we'll ask for more context by setting `similarityTopK` to 10.
-
-Now, we can create an agent using the `QueryEngineTool`:
-
-```javascript
 // Create an agent using the tools array
 const ragAgent = agent({ tools });
 

apps/next/src/content/docs/llamaindex/tutorials/agents/5_rag_and_tools.mdx

@@ -12,7 +12,6 @@ const tools = [
       name: "san_francisco_budget_tool",
       description: `This tool can answer detailed questions about the individual components of the budget of San Francisco in 2023-2024.`,
     },
-    options: { similarityTopK: 10 },
   }),
   tool({
     name: "sumNumbers",

apps/next/src/content/docs/llamaindex/tutorials/basic_agent.mdx

@@ -8,10 +8,9 @@ We have a comprehensive, step-by-step [guide to building agents in LlamaIndex.TS
 
 In a new folder:
 
-```package-install
+```bash npm2yarn
 npm init
 npm i -D typescript @types/node
-npm i @llamaindex/openai @llamaindex/workflow llamaindex zod
 ```
 
 ## Run agent
@@ -21,14 +20,15 @@ Create the file `example.ts`. This code will:
 - Create two tools for use by the agent:
   - A `sumNumbers` tool that adds two numbers
   - A `divideNumbers` tool that divides numbers
+-
 - Give an example of the data structure we wish to generate
 - Prompt the LLM with instructions and the example, plus a sample transcript
 
-<include cwd>../../examples/agents/agent/openai.ts</include>
+<include cwd>../../examples/agent/openai.ts</include>
 
 To run the code:
 
-```package-install
+```bash
 npx tsx example.ts
 ```
 
@@ -36,18 +36,9 @@ You should expect output something like:
 
 ```
 {
-  result: '5 + 5 is 10. Then, 10 divided by 2 is 5.',
-  state: {
-    memory: ChatMemoryBuffer {
-      chatStore: SimpleChatStore {},
-      chatStoreKey: 'chat_history',
-      tokenLimit: 750000
-    },
-    scratchpad: [],
-    currentAgentName: 'Agent',
-    agents: [ 'Agent' ],
-    nextAgentName: null
-  }
+  content: 'The sum of 5 + 5 is 10. When you divide 10 by 2, you get 5.',
+  role: 'assistant',
+  options: {}
 }
 Done
 ```

apps/next/src/content/docs/llamaindex/tutorials/meta.json

@@ -4,7 +4,7 @@
     "basic_agent",
     "rag",
     "agents",
-    "workflows",
+    "workflow",
     "local_llm",
     "chatbot",
     "structured_data_extraction"

apps/next/src/content/docs/llamaindex/tutorials/rag/concepts.mdx

@@ -16,7 +16,7 @@ LlamaIndex uses a two stage method when using an LLM with your data:
 1. **indexing stage**: preparing a knowledge base, and
 2. **querying stage**: retrieving relevant context from the knowledge to assist the LLM in responding to a question
 
-![](/_static/concepts/rag.jpg)
+![](./_static/concepts/rag.jpg)
 
 This process is also known as Retrieval Augmented Generation (RAG).
 
@@ -28,7 +28,7 @@ Let's explore each stage in detail.
 
 LlamaIndex.TS help you prepare the knowledge base with a suite of data connectors and indexes.
 
-![](/_static/concepts/indexing.jpg)
+![](./_static/concepts/indexing.jpg)
 
 [**Data Loaders**](/docs/llamaindex/modules/data/readers):
 A data connector (i.e. `Reader`) ingest data from different data sources and data formats into a simple `Document` representation (text and simple metadata).
@@ -54,7 +54,7 @@ LlamaIndex provides composable modules that help you build and integrate RAG pip
 
 These building blocks can be customized to reflect ranking preferences, as well as composed to reason over multiple knowledge bases in a structured way.
 
-![](/_static/concepts/querying.jpg)
+![](./_static/concepts/querying.jpg)
 
 #### Building Blocks
 

apps/next/src/content/docs/llamaindex/tutorials/rag/index.mdx

@@ -8,10 +8,9 @@ One of the most common use-cases for LlamaIndex is Retrieval-Augmented Generatio
 
 In a new folder, run:
 
-```package-install
+```bash npm2yarn
 npm init
 npm i -D typescript @types/node
-npm i llamaindex
 ```
 
 Then, check out the [installation](/docs/llamaindex/getting_started/installation) steps to install LlamaIndex.TS and prepare an OpenAI key.
@@ -27,7 +26,7 @@ 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
 
-<include cwd>../../examples/index/vectorIndex.ts</include>
+<include cwd>../../examples/vectorIndex.ts</include>
 
 Create a `tsconfig.json` file in the same folder:
 
@@ -35,7 +34,7 @@ Create a `tsconfig.json` file in the same folder:
 
 Now you can run the code with
 
-```package-install
+```bash
 npx tsx example.ts
 ```
 

apps/next/src/content/docs/llamaindex/tutorials/structured_data_extraction.mdx

@@ -10,10 +10,9 @@ You can use [other LLMs](/docs/llamaindex/modules/models/llms) via their APIs; i
 
 In a new folder:
 
-```package-install
+```bash npm2yarn
 npm init
 npm i -D typescript @types/node
-npm i @llamaindex/openai zod
 ```
 
 ## Extract data
@@ -24,11 +23,11 @@ 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
 
-<include cwd>../../examples/misc/jsonExtract.ts</include>
+<include cwd>../../examples/jsonExtract.ts</include>
 
 To run the code:
 
-```package-install
+```bash
 npx tsx example.ts
 ```
 

apps/next/src/content/docs/llamaindex/tutorials/workflow/advanced-events.mdx

@@ -0,0 +1,530 @@
+---
+title: Advanced Event Handling
+description: Master complex event patterns and middleware with Workflows
+---
+
+This guide explores advanced event handling techniques and patterns you can use with Workflows to build more sophisticated patterns.
+
+## Event Composition
+
+Workflows allow you to work with different event types and compose them in powerful ways:
+
+### Multiple Event Types
+
+You can define multiple event types for different kinds of data flowing through your workflow:
+
+```ts
+import { createWorkflow, workflowEvent } from "llamaindex";
+
+// Define different event types
+const textEvent = workflowEvent<string>();
+const numberEvent = workflowEvent<number>();
+const booleanEvent = workflowEvent<boolean>();
+const complexEvent = workflowEvent<{ id: string; value: number }>();
+
+// Create a workflow that can process different event types
+const workflow = createWorkflow();
+
+// Handle text events
+workflow.handle([textEvent], (event) => {
+  console.log(`Processing text: ${event.data}`);
+  return numberEvent.with(event.data.length);
+});
+
+// Handle number events
+workflow.handle([numberEvent], (event) => {
+  const isEven = event.data % 2 === 0;
+  console.log(`Number ${event.data} is ${isEven ? 'even' : 'odd'}`);
+  return booleanEvent.with(isEven);
+});
+
+// Handle boolean events
+workflow.handle([booleanEvent], (event) => {
+  return complexEvent.with({
+    id: crypto.randomUUID(),
+    value: event.data ? 100 : 0
+  });
+});
+```
+
+### Event Branching and Merging
+
+You can create complex event flows with branching and merging patterns:
+
+```ts
+import { createWorkflow, workflowEvent, until, collect } from "llamaindex";
+
+// Define events for a data processing pipeline
+const inputEvent = workflowEvent<string>();
+const validateEvent = workflowEvent<string>();
+const processEvent = workflowEvent<string>();
+const errorEvent = workflowEvent<Error>();
+const resultEvent = workflowEvent<string>();
+const completeEvent = workflowEvent<string[]>();
+
+// Create workflow
+const workflow = createWorkflow();
+
+// Branch based on input validation
+workflow.handle([inputEvent], (event) => {
+  if (event.data && event.data.trim().length > 0) {
+    return validateEvent.with(event.data.trim());
+  } else {
+    return errorEvent.with(new Error("Empty input"));
+  }
+});
+
+// Process valid inputs
+workflow.handle([validateEvent], (event) => {
+  return processEvent.with(event.data.toUpperCase());
+});
+
+// Handle processing
+workflow.handle([processEvent], (event) => {
+  return resultEvent.with(`Processed: ${event.data}`);
+});
+
+// Handle errors
+workflow.handle([errorEvent], (event) => {
+  return resultEvent.with(`Error: ${event.data.message}`);
+});
+
+// Merge results: collect multiple results into a single completion event
+workflow.handle([inputEvent], (start) => {
+  const { sendEvent, stream } = getContext();
+  
+  // Process all inputs
+  const inputs = start.data.split(',').map(s => s.trim());
+  inputs.forEach(input => sendEvent(inputEvent.with(input)));
+  
+  // Collect all results
+  const results = await collect(
+    until(stream, result => resultEvent.include(result))
+      .filter(ev => resultEvent.include(ev))
+      .take(inputs.length)
+  );
+  
+  return completeEvent.with(results.map(r => r.data));
+});
+```
+
+## Event Filtering and Transformation
+
+You can filter and transform events to build sophisticated data processing pipelines:
+
+```ts
+import { createWorkflow, workflowEvent } from "llamaindex";
+
+// Define events
+const dataEvent = workflowEvent<number>();
+const evenEvent = workflowEvent<number>();
+const oddEvent = workflowEvent<number>();
+const transformedEvent = workflowEvent<string>();
+const resultEvent = workflowEvent<string[]>();
+
+// Create workflow
+const workflow = createWorkflow();
+
+// Filter even numbers
+workflow.handle([dataEvent], (event) => {
+  if (event.data % 2 === 0) {
+    return evenEvent.with(event.data);
+  } else {
+    return oddEvent.with(event.data);
+  }
+});
+
+// Transform even numbers
+workflow.handle([evenEvent], (event) => {
+  return transformedEvent.with(`Even: ${event.data}`);
+});
+
+// Transform odd numbers
+workflow.handle([oddEvent], (event) => {
+  return transformedEvent.with(`Odd: ${event.data}`);
+});
+
+// Collect and organize results
+workflow.handle([dataEvent], (start) => {
+  const { sendEvent, stream } = getContext();
+  
+  // Generate a sequence of numbers
+  for (let i = 1; i <= 10; i++) {
+    sendEvent(dataEvent.with(i));
+  }
+  
+  // Collect transformed events
+  const results = await collect(
+    until(stream)
+      .filter(ev => transformedEvent.include(ev))
+      .take(10)
+  );
+  
+  return resultEvent.with(results.map(r => r.data));
+});
+```
+
+## Working with `withTraceEvents` Middleware
+
+The `withTraceEvents` middleware adds powerful tracing capabilities to your workflows:
+
+```ts
+import { 
+  createWorkflow, 
+  workflowEvent,
+  withTraceEvents,
+  runOnce,
+  createHandlerDecorator
+} from "llamaindex";
+
+// Define events
+const startEvent = workflowEvent<string>();
+const processEvent = workflowEvent<string>();
+const resultEvent = workflowEvent<string>();
+
+// Create workflow with tracing
+const workflow = withTraceEvents(createWorkflow());
+
+// Create a custom handler decorator that logs execution time
+const measureTime = createHandlerDecorator({
+  debugLabel: "measureTime",
+  getInitialValue: () => performance.now(),
+  onBeforeHandler: (handler, context, startTime) => {
+    console.log(`Starting handler execution at ${new Date().toISOString()}`);
+    return handler;
+  },
+  onAfterHandler: (result, context, startTime) => {
+    const duration = performance.now() - startTime;
+    console.log(`Handler executed in ${duration.toFixed(2)}ms`);
+    return startTime; // Return the initial value for next execution
+  }
+});
+
+// Run a specific handler only once
+workflow.handle(
+  [startEvent],
+  runOnce((event) => {
+    console.log("This handler will only run once per workflow context");
+    return processEvent.with(event.data);
+  })
+);
+
+// Measure the execution time of this handler
+workflow.handle(
+  [processEvent],
+  measureTime((event) => {
+    // Simulate processing time
+    const start = Date.now();
+    while (Date.now() - start < 100) {
+      // Busy wait for 100ms
+    }
+    return resultEvent.with(`Processed: ${event.data}`);
+  })
+);
+```
+
+### Debugging with Substreams
+
+You can use the `substream` feature to debug specific event flows:
+
+```ts
+import { createWorkflow, workflowEvent, withTraceEvents } from "llamaindex";
+
+// Define events
+const queryEvent = workflowEvent<string>();
+const fetchEvent = workflowEvent<string>();
+const resultEvent = workflowEvent<string>();
+
+// Create workflow with tracing
+const workflow = withTraceEvents(createWorkflow());
+
+// Query handler
+workflow.handle([queryEvent], (event) => {
+  const { sendEvent, stream } = getContext();
+  
+  // Create a specific fetch event for this query
+  const fetchInstance = fetchEvent.with(event.data);
+  sendEvent(fetchInstance);
+  
+  // Create a substream to only track events related to this fetch
+  const substream = workflow.substream(fetchInstance, stream);
+  
+  // Listen for results in the substream
+  (async () => {
+    for await (const event of substream) {
+      console.log(`Event in substream: ${event.type}`);
+    }
+  })();
+  
+  return resultEvent.with(`Querying: ${event.data}`);
+});
+
+// Fetch handler
+workflow.handle([fetchEvent], (event) => {
+  console.log(`Fetching data for: ${event.data}`);
+  // Actual fetch logic would go here
+  return resultEvent.with(`Results for: ${event.data}`);
+});
+```
+
+## Advanced Validation and Type Safety
+
+The `withValidation` middleware ensures your workflow connections are both type-safe and runtime-safe:
+
+```ts
+import { createWorkflow, workflowEvent, withValidation } from "llamaindex";
+
+// Define events with explicit types
+const inputEvent = workflowEvent<string, "input">();
+const validateEvent = workflowEvent<string, "validate">();
+const processEvent = workflowEvent<string, "process">();
+const resultEvent = workflowEvent<string, "result">();
+const errorEvent = workflowEvent<Error, "error">({
+  debugLabel: "errorEvent" // Add debug labels for better error messages
+});
+
+// Define the allowed event flow paths
+const workflow = withValidation(
+  createWorkflow(),
+  [
+    [[inputEvent], [validateEvent, errorEvent]],    // inputEvent can lead to validateEvent or errorEvent
+    [[validateEvent], [processEvent, errorEvent]],  // validateEvent can lead to processEvent or errorEvent
+    [[processEvent], [resultEvent, errorEvent]],    // processEvent can lead to resultEvent or errorEvent
+    [[errorEvent], [resultEvent]]                   // errorEvent can lead to resultEvent
+  ]
+);
+
+// Now use strictHandle to get compile-time validation
+workflow.strictHandle([inputEvent], (sendEvent, event) => {
+  try {
+    if (!event.data || event.data.trim().length === 0) {
+      throw new Error("Empty input");
+    }
+    // This is allowed by our validation rules
+    sendEvent(validateEvent.with(event.data.trim()));
+    
+    // This would cause a compile-time error:
+    // sendEvent(resultEvent.with("Result")); // ❌ Not allowed by validation rules
+  } catch (err) {
+    // This is allowed by our validation rules
+    sendEvent(errorEvent.with(err instanceof Error ? err : new Error(String(err))));
+  }
+});
+
+// The rest of the workflow with strict validation
+workflow.strictHandle([validateEvent], (sendEvent, event) => {
+  // Validation logic here
+  sendEvent(processEvent.with(event.data));
+});
+
+workflow.strictHandle([processEvent], (sendEvent, event) => {
+  // Processing logic here
+  sendEvent(resultEvent.with(`Processed: ${event.data}`));
+});
+
+workflow.strictHandle([errorEvent], (sendEvent, event) => {
+  // Error handling logic here
+  sendEvent(resultEvent.with(`Error handled: ${event.data.message}`));
+});
+```
+
+## Creating Custom Middleware
+
+You can create your own middleware to extend the workflow capabilities:
+
+```ts
+import { createWorkflow, workflowEvent } from "llamaindex";
+
+// Create a logging middleware
+function withLogging(workflow) {
+  const originalHandle = workflow.handle;
+  
+  workflow.handle = function(eventTypes, handler) {
+    return originalHandle.call(workflow, eventTypes, async function(...args) {
+      const eventType = eventTypes.map(e => e.name || 'AnonymousEvent').join(',');
+      console.log(`[${new Date().toISOString()}] Handling ${eventType}`);
+      
+      try {
+        const result = await handler(...args);
+        console.log(`[${new Date().toISOString()}] Completed ${eventType}`);
+        return result;
+      } catch (error) {
+        console.error(`[${new Date().toISOString()}] Error in ${eventType}:`, error);
+        throw error;
+      }
+    });
+  };
+  
+  return workflow;
+}
+
+// Create a retry middleware
+function withRetry(maxRetries = 3, workflow) {
+  const originalHandle = workflow.handle;
+  
+  workflow.handle = function(eventTypes, handler) {
+    return originalHandle.call(workflow, eventTypes, async function(...args) {
+      let lastError;
+      
+      for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+          return await handler(...args);
+        } catch (error) {
+          lastError = error;
+          console.warn(`Attempt ${attempt}/${maxRetries} failed:`, error);
+          
+          if (attempt < maxRetries) {
+            // Exponential backoff
+            await new Promise(resolve => 
+              setTimeout(resolve, Math.pow(2, attempt - 1) * 100)
+            );
+          }
+        }
+      }
+      
+      throw lastError;
+    });
+  };
+  
+  return workflow;
+}
+
+// Use the custom middleware
+const workflow = withRetry(3, withLogging(createWorkflow()));
+
+// Define events
+const startEvent = workflowEvent<string>();
+const resultEvent = workflowEvent<string>();
+
+// Add handlers
+workflow.handle([startEvent], (event) => {
+  // This handler might fail but will be retried
+  if (Math.random() < 0.7) {
+    throw new Error("Random failure");
+  }
+  return resultEvent.with(`Processed: ${event.data}`);
+});
+```
+
+## Integrating with External Systems
+
+You can extend your workflows to integrate with external systems:
+
+```ts
+import { createWorkflow, workflowEvent } from "llamaindex";
+
+// Define events
+const fetchEvent = workflowEvent<string>();
+const successEvent = workflowEvent<any>();
+const failureEvent = workflowEvent<Error>();
+
+// Create workflow
+const workflow = createWorkflow();
+
+// Handle external API calls with proper error handling
+workflow.handle([fetchEvent], async (event) => {
+  const { signal } = getContext();
+  
+  try {
+    // Use AbortSignal for cancellation support
+    const response = await fetch(event.data, { signal });
+    
+    if (!response.ok) {
+      throw new Error(`HTTP error: ${response.status}`);
+    }
+    
+    const data = await response.json();
+    return successEvent.with(data);
+  } catch (error) {
+    if (error.name === 'AbortError') {
+      return failureEvent.with(new Error('Request was aborted'));
+    }
+    return failureEvent.with(error instanceof Error ? error : new Error(String(error)));
+  }
+});
+
+// Database integration example
+const dbQueryEvent = workflowEvent<{ collection: string; query: any }>();
+const dbResultEvent = workflowEvent<any[]>();
+
+workflow.handle([dbQueryEvent], async (event) => {
+  // Connect to database (pseudo-code)
+  const db = await connectToDatabase();
+  
+  try {
+    const results = await db.collection(event.data.collection)
+      .find(event.data.query)
+      .toArray();
+      
+    return dbResultEvent.with(results);
+  } catch (error) {
+    return failureEvent.with(error);
+  } finally {
+    await db.close();
+  }
+});
+```
+
+## Handling Complex Asynchronous Patterns
+
+LlamaIndex workflows excel at managing complex asynchronous patterns:
+
+```ts
+import { createWorkflow, workflowEvent, until, collect } from "llamaindex";
+
+// Events for an orchestration workflow
+const orchestrateEvent = workflowEvent<string[]>();
+const taskEvent = workflowEvent<string>();
+const progressEvent = workflowEvent<{ task: string; progress: number }>();
+const taskCompleteEvent = workflowEvent<string>();
+const aggregateEvent = workflowEvent<any>();
+
+// Create workflow
+const workflow = createWorkflow();
+
+// Orchestrator: distribute tasks and collect results
+workflow.handle([orchestrateEvent], async (event) => {
+  const { sendEvent, stream } = getContext();
+  const tasks = event.data;
+  
+  // Start all tasks
+  tasks.forEach(task => sendEvent(taskEvent.with(task)));
+  
+  // Track progress
+  let completed = 0;
+  const results = {};
+  
+  // Process task completion and progress events
+  for await (const event of until(stream, () => completed === tasks.length)) {
+    if (progressEvent.include(event)) {
+      console.log(`Task ${event.data.task}: ${event.data.progress}%`);
+    } else if (taskCompleteEvent.include(event)) {
+      completed++;
+      results[event.data] = `Completed ${event.data}`;
+      console.log(`Completed ${completed}/${tasks.length} tasks`);
+    }
+  }
+  
+  return aggregateEvent.with(results);
+});
+
+// Task processor
+workflow.handle([taskEvent], async (event) => {
+  const { sendEvent } = getContext();
+  const task = event.data;
+  
+  // Simulate task processing with progress updates
+  for (let progress = 0; progress <= 100; progress += 20) {
+    sendEvent(progressEvent.with({ task, progress }));
+    await new Promise(resolve => setTimeout(resolve, 200));
+  }
+  
+  return taskCompleteEvent.with(task);
+});
+```
+
+## Next Steps
+
+Now that you've explored advanced event handling with workflows, you're ready to build sophisticated applications:
+
+- [Integrating Workflows with other LlamaIndex Features](./llamaindex-integration.mdx) 

apps/next/src/content/docs/llamaindex/tutorials/workflow/basic-workflow.mdx

@@ -0,0 +1,263 @@
+---
+title: Basic Workflow Patterns
+description: Learn common patterns and techniques for building effective workflows
+---
+
+This guide explores common patterns you can use to build more complex workflows with workflows.
+
+## Fan-out (Parallelism)
+
+One of the most powerful features of workflows is the ability to run tasks in parallel:
+
+```ts
+import { createWorkflow, workflowEvent, until, collect } from "llamaindex";
+
+// Define events
+const startEvent = workflowEvent<string>();
+const processItemEvent = workflowEvent<number>();
+const resultEvent = workflowEvent<string>();
+const completeEvent = workflowEvent<string[]>();
+
+// Create workflow
+const workflow = createWorkflow();
+
+// Process start event: fan out to multiple processItemEvent events
+workflow.handle([startEvent], (start) => {
+  const { sendEvent, stream } = getContext();
+  
+  // Emit multiple events to be processed in parallel
+  for (let i = 0; i < 10; i++) {
+    sendEvent(processItemEvent.with(i));
+  }
+  
+  // Collect all resultEvents and emit a final completeEvent
+  let condition = false;
+  const results = collect(
+    until(stream, () => condition)
+      .filter((ev) => resultEvent.includes(ev))
+  );
+  
+  return completeEvent.with(results.map(event => event.data));
+});
+
+// Process each item
+workflow.handle([processItemEvent], (event) => {
+  // Process the item
+  const processedValue = `Processed: ${event.data}`;
+  
+  // If this is the last item, set the condition to stop collecting
+  if (event.data === 9) {
+    condition = true;
+  }
+  
+  return resultEvent.with(processedValue);
+});
+```
+
+This pattern allows you to:
+1. Emit multiple events to be processed in parallel
+2. Collect results as they come in
+3. Complete once all parallel tasks are finished
+
+## Conditional Branching
+
+You can implement conditional logic in your workflows:
+
+```ts
+import { createWorkflow, workflowEvent } from "llamaindex";
+
+const inputEvent = workflowEvent<number>();
+const evenNumberEvent = workflowEvent<string>();
+const oddNumberEvent = workflowEvent<string>();
+const resultEvent = workflowEvent<string>();
+
+const workflow = createWorkflow();
+
+// Branch based on whether the number is even or odd
+workflow.handle([inputEvent], (event) => {
+  if (event.data % 2 === 0) {
+    return evenNumberEvent.with(`${event.data} is even`);
+  } else {
+    return oddNumberEvent.with(`${event.data} is odd`);
+  }
+});
+
+// Handle even numbers
+workflow.handle([evenNumberEvent], (event) => {
+  return resultEvent.with(`Even result: ${event.data}`);
+});
+
+// Handle odd numbers
+workflow.handle([oddNumberEvent], (event) => {
+  return resultEvent.with(`Odd result: ${event.data}`);
+});
+```
+
+## Using Middleware
+
+LlamaIndex workflows provide middleware that can enhance your workflows:
+
+### `withStore` Middleware
+
+The `withStore` middleware adds a persistent store to your workflow context:
+
+```ts
+import { createWorkflow, workflowEvent, withStore } from "llamaindex";
+
+const startEvent = workflowEvent<void>();
+const incrementEvent = workflowEvent<number>();
+const resultEvent = workflowEvent<number>();
+
+// Create a workflow with store middleware
+const workflow = withStore(
+  () => ({
+    count: 0,
+    history: [] as number[],
+  }), 
+  createWorkflow()
+);
+
+// Increment the counter
+workflow.handle([startEvent], () => {
+  const store = workflow.getStore();
+  store.count += 1;
+  store.history.push(store.count);
+  return incrementEvent.with(store.count);
+});
+
+// Return the current count
+workflow.handle([incrementEvent], (event) => {
+  const store = workflow.getStore();
+  return resultEvent.with(store.count);
+});
+```
+
+### `withValidation` Middleware
+
+The `withValidation` middleware adds compile-time and runtime validation to your workflows:
+
+```ts
+import { createWorkflow, workflowEvent, withValidation } from "llamaindex";
+
+const startEvent = workflowEvent<string, "start">();
+const processEvent = workflowEvent<number, "process">();
+const resultEvent = workflowEvent<string, "result">();
+const disallowedEvent = workflowEvent<void, "disallowed">();
+
+// Create a workflow with validation middleware
+// Define allowed event paths
+const workflow = withValidation(
+  createWorkflow(), 
+  [
+    [[startEvent], [processEvent]], // startEvent can only lead to processEvent
+    [[processEvent], [resultEvent]], // processEvent can only lead to resultEvent
+  ]
+);
+
+// This will pass validation
+workflow.strictHandle([startEvent], (sendEvent, start) => {
+  sendEvent(processEvent.with(123)); // ✅ This is allowed
+});
+
+// This would fail at compile time and runtime
+workflow.strictHandle([startEvent], (sendEvent, start) => {
+  // sendEvent(disallowedEvent.with()); // ❌ This would cause an error
+  // sendEvent(resultEvent.with("result")); // ❌ This would also cause an error
+});
+```
+
+## Error Handling
+
+LlamaIndex workflows provide built-in mechanisms for handling errors:
+
+```ts
+import { createWorkflow, workflowEvent } from "llamaindex";
+
+const startEvent = workflowEvent<string>();
+const processEvent = workflowEvent<number>();
+const errorEvent = workflowEvent<Error>();
+const resultEvent = workflowEvent<string>();
+
+const workflow = createWorkflow();
+
+workflow.handle([startEvent], (start) => {
+  try {
+    const num = Number.parseInt(start.data, 10);
+    if (isNaN(num)) {
+      throw new Error("Invalid number");
+    }
+    return processEvent.with(num);
+  } catch (err) {
+    return errorEvent.with(err instanceof Error ? err : new Error(String(err)));
+  }
+});
+
+workflow.handle([processEvent], (event) => {
+  return resultEvent.with(`Result: ${event.data * 2}`);
+});
+
+workflow.handle([errorEvent], (event) => {
+  return resultEvent.with(`Error: ${event.data.message}`);
+});
+```
+
+You can also use the signal in `getContext()` to handle errors:
+
+```ts
+workflow.handle([processEvent], () => {
+  const { signal } = getContext();
+
+  signal.onabort = () => {
+    console.error("Process aborted:", signal.reason);
+    // Clean up resources
+  };
+  
+  // Your processing logic here
+});
+```
+
+## Connecting with Server Endpoints
+
+Workflow can be used as middleware in server frameworks like Express, Hono, or Fastify:
+
+```ts
+import { Hono } from "hono";
+import { serve } from "@hono/node-server";
+import { createWorkflow, workflowEvent, createHonoHandler } from "llamaindex";
+
+// Define events
+const queryEvent = workflowEvent<string>();
+const responseEvent = workflowEvent<string>();
+
+// Create workflow
+const workflow = createWorkflow();
+
+workflow.handle([queryEvent], (event) => {
+  const response = `Processed: ${event.data}`;
+  return responseEvent.with(response);
+});
+
+// Create Hono app
+const app = new Hono();
+
+// Set up workflow endpoint
+app.post(
+  "/workflow",
+  createHonoHandler(
+    workflow,
+    async (ctx) => queryEvent.with(await ctx.req.text()),
+    responseEvent
+  )
+);
+
+// Start server
+serve(app, ({ port }) => {
+  console.log(`Server started at http://localhost:${port}`);
+});
+```
+
+## Next Steps
+
+Now that you've learned about basic workflow patterns, explore more advanced topics:
+- [Streaming with Workflows](./streaming.mdx)
+- [Advanced Event Handling](./advanced-events.mdx) 

apps/next/src/content/docs/llamaindex/tutorials/workflow/different-inputs-outputs.mdx

@@ -0,0 +1,234 @@
+---
+title: Inputs / Outputs (Outdated)
+description: This page has been replaced with newer documentation
+---
+
+# ⚠️ Outdated Documentation
+
+This documentation is for an older version of the workflow API. Please refer to the new llama-flow documentation:
+
+- [Getting Started with llama-flow](./index.mdx)
+- [Basic Workflow Patterns](./basic-workflow.mdx)
+- [Advanced Event Handling](./advanced-events.mdx)
+
+The new API provides a more lightweight and flexible approach to building workflows.
+
+Inputs and outputs are the way to communicate between steps in a workflow. In the previous example,
+we used `StartEvent` and `StopEvent` to communicate between steps. However, you can use any type of event to communicate between steps.
+
+## Multiple inputs
+
+You can define multiple inputs for a step.
+
+In the following example, we define a complex workflow with multiple inputs and outputs.
+
+```ts twoslash
+import { Workflow, StartEvent, StopEvent, WorkflowEvent } from '@llamaindex/workflow';
+
+class AEvent extends WorkflowEvent<string> {
+	constructor(data: string) {
+		super(data);
+	}
+}
+
+class BEvent extends WorkflowEvent<number> {
+	constructor(data: number) {
+		super(data);
+	}
+}
+
+class ResultEvent extends WorkflowEvent<string> {
+	constructor(data: string) {
+		super(data);
+	}
+}
+```
+
+First, let's define the events that we will use in the workflow.
+
+```ts twoslash
+import { Workflow, StartEvent, StopEvent, WorkflowEvent } from '@llamaindex/workflow';
+
+class AEvent extends WorkflowEvent<string> {
+	constructor(data: string) {
+		super(data);
+	}
+}
+
+class BEvent extends WorkflowEvent<number> {
+	constructor(data: number) {
+		super(data);
+	}
+}
+
+class ResultEvent extends WorkflowEvent<string> {
+	constructor(data: string) {
+		super(data);
+	}
+}
+
+const workflow = new Workflow<never, string, string>();
+
+workflow.addStep({
+	inputs: [StartEvent<string>],
+	outputs: [StopEvent<string>]
+}, async (
+	context,
+	startEvent
+) => {
+	const input = startEvent.data;
+	const aEvent = await context.requireEvent(AEvent);
+	const bEvent = await context.requireEvent(BEvent);
+	const a = aEvent.data;
+	const b = bEvent.data;
+	return new StopEvent(`Hello, ${input}! A: ${a}, B: ${b}`);
+});
+
+// ---cut---
+workflow.addStep({
+	inputs: [AEvent, BEvent],
+	outputs: [ResultEvent]
+}, async (
+	context,
+	aEvent,
+	bEvent
+) => {
+	const a = aEvent.data;
+	const b = bEvent.data;
+	return new ResultEvent(`A: ${a}, B: ${b}`);
+});
+```
+
+This step means that it requires two events: `AEvent` and `BEvent`. It will return a `ResultEvent` with the data `A: ${a}, B: ${b}`.
+
+## A or B input
+
+If we want to have a step that can accept either `AEvent` or `BEvent`, we can define the step like this:
+
+```ts twoslash
+import { Workflow, StartEvent, StopEvent, WorkflowEvent } from '@llamaindex/workflow';
+
+class AEvent extends WorkflowEvent<string> {
+	constructor(data: string) {
+		super(data);
+	}
+}
+
+class BEvent extends WorkflowEvent<number> {
+	constructor(data: number) {
+		super(data);
+	}
+}
+
+class ResultEvent extends WorkflowEvent<string> {
+	constructor(data: string) {
+		super(data);
+	}
+}
+
+const workflow = new Workflow<never, string, string>();
+
+workflow.addStep({
+	inputs: [StartEvent<string>],
+	outputs: [StopEvent<string>]
+}, async (
+	context,
+	startEvent
+) => {
+	const input = startEvent.data;
+	const aEvent = await context.requireEvent(AEvent);
+	const bEvent = await context.requireEvent(BEvent);
+	const a = aEvent.data;
+	const b = bEvent.data;
+	return new StopEvent(`Hello, ${input}! A: ${a}, B: ${b}`);
+});
+
+// ---cut---
+workflow.addStep({
+	inputs: [WorkflowEvent.or(AEvent, BEvent)],
+	outputs: [ResultEvent]
+}, async (
+	context,
+	aOrBEvent
+) => {
+	if (aOrBEvent instanceof AEvent) {
+		// ^?
+
+
+		const a = aOrBEvent.data;
+		//        ^?
+
+
+		return new ResultEvent(`A: ${a}`);
+	} else {
+		const b = aOrBEvent.data;
+		//        ^?
+
+
+		return new ResultEvent(`B: ${b}`);
+	}
+});
+```
+
+This step means that it requires either `AEvent` or `BEvent`. It will return a `ResultEvent` with the data `A: ${a}` or `B: ${b}`.
+
+You can still combine the logic with `context.requireEvent` to get the data from the event.
+
+<Accordions>
+	<Accordion title="Under the hood">
+		We use JavaScript Inheritance and the prototype chain to implement the `or` logic.
+		The `or` method creates a new class that extends the two classes that you pass to it.
+
+		<a
+			target="_blank"
+			href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Inheritance_and_the_prototype_chain"
+		>
+			MDN - Inheritance and the prototype chain
+		</a>
+	</Accordion>
+</Accordions>
+
+## Multiple outputs
+
+You can define multiple outputs for a step.
+
+```ts twoslash
+import { Workflow, StartEvent, StopEvent, WorkflowEvent } from '@llamaindex/workflow';
+
+class AEvent extends WorkflowEvent<string> {
+	constructor(data: string) {
+		super(data);
+	}
+}
+
+class BEvent extends WorkflowEvent<number> {
+	constructor(data: number) {
+		super(data);
+	}
+}
+
+class ResultEvent extends WorkflowEvent<string> {
+	constructor(data: string) {
+		super(data);
+	}
+}
+
+const workflow = new Workflow<never, string, string>();
+// ---cut---
+workflow.addStep({
+	inputs: [StartEvent<string>],
+	outputs: [AEvent, BEvent]
+}, async (
+	context,
+	startEvent
+) => {
+	const input = startEvent.data;
+	if (Math.random() > 0.5) {
+		return new AEvent(`Hello, ${input}!`);
+	} else {
+		return new BEvent(42);
+	}
+});
+```
+
+This step will return either an `AEvent` or a `BEvent` based on a random number.

apps/next/src/content/docs/llamaindex/tutorials/workflow/index.mdx

@@ -0,0 +1,111 @@
+---
+title: Getting Started with Workflows
+description: Learn how to use LlamaIndex's lightweight workflow engine for TypeScript
+---
+
+Workflows are a simple and lightweight engine for TypeScript. Built with ❤️ by LlamaIndex.
+
+- Minimal core API (\<\=2kb)
+- 100% Type safe
+- Event-driven, stream oriented programming
+- Support for multiple JS runtimes/frameworks
+
+## Installation
+
+It's directly included with the `llamaindex` package:
+
+```shell
+npm i llamaindex
+```
+
+But can also be installed separately:
+
+```shell
+npm i @llama-flow/core
+
+# or with yarn
+yarn add @llama-flow/core
+
+# or with pnpm
+pnpm add @llama-flow/core
+```
+
+## Key Concepts
+
+- **Events**: Data carriers that flow through the workflow
+- **Handlers**: Functions that process events and emit new events
+- **Workflow**: Connects events and handlers together
+- **Context**: Runtime environment for a workflow execution
+
+## Basic Usage
+
+Let's build a simple workflow that processes a text input:
+
+### 1. Define events
+
+First, we need to define the events that will flow through our workflow:
+
+```ts
+import { workflowEvent } from "llamaindex";
+
+// Define input and output events
+const startEvent = workflowEvent<string>(); // Takes a string input
+const convertEvent = workflowEvent<Number>();       // Intermediate event
+const stopEvent = workflowEvent<1 | -1>();  // Final output event, returns 1 or -1
+```
+
+### 2. Create a workflow and connect events
+
+Next, we'll create our workflow and define how events are processed:
+
+```ts
+import { createWorkflow } from "llamaindex";
+
+const workflow = createWorkflow();
+
+// Handle the start event: convert the string to a number
+workflow.handle([startEvent], (start) => {
+  return convertEvent.with(Number.parseInt(start.data, 10));
+});
+
+// Handle the convert event: determine if number is positive or negative
+workflow.handle([convertEvent], (convert) => {
+  return stopEvent.with(convert.data > 0 ? 1 : -1);
+});
+```
+
+### 3. Run the workflow
+
+Finally, we can execute our workflow:
+
+```ts
+// Create a workflow context and send the initial event
+const { stream, sendEvent } = workflow.createContext();
+sendEvent(startEvent.with("42"));
+
+// Process the stream to get the result
+import { pipeline } from "node:stream/promises";
+
+const result = await pipeline(stream, async function (source) {
+  for await (const event of source) {
+    if (stopEvent.include(event)) {
+      return `Result: ${event.data === 1 ? 'positive' : 'negative'}`;
+    }
+  }
+});
+
+console.log(result); // "Result: positive"
+```
+
+Or using the stream utilities:
+
+```ts
+import { collect, until } from "llamaindex";
+
+// Collect all events until we get a stopEvent
+const allEvents = await collect(until(stream, stopEvent));
+const finalEvent = allEvents[allEvents.length - 1];
+console.log(`Result: ${finalEvent.data === 1 ? 'positive' : 'negative'}`);
+```
+
+Ready to learn more? Check out our [detailed examples](./basic-workflow.mdx) to see llama-flow in action!

apps/next/src/content/docs/llamaindex/tutorials/workflow/llamaindex-integration.mdx

@@ -0,0 +1,288 @@
+---
+title: Integrating with LlamaIndex
+description: Build AI applications by combining Workflows with other LlamaIndex features
+---
+
+This guide demonstrates how to combine the power of the workflow engine with LlamaIndex's retrieval and reasoning capabilities to build sophisticated AI applications.
+
+## Basic RAG Workflow
+
+Let's build a simple Retrieval-Augmented Generation (RAG) workflow:
+
+```ts
+import { createWorkflow, workflowEvent } from "llamaindex";
+import { Document, serviceContextFromDefaults, VectorStoreIndex } from "llamaindex";
+import { OpenAI, OpenAIEmbedding } from "@llamaindex/openai";
+import { Settings } from "@llamaindex/core/global"
+
+// Define events
+const queryEvent = workflowEvent<string>();
+const retrieveEvent = workflowEvent<{ query: string; documents: Document[] }>();
+const generateEvent = workflowEvent<{ query: string; context: string }>();
+const responseEvent = workflowEvent<string>();
+
+// Create workflow
+const workflow = createWorkflow();
+
+// Set default global llm
+Settings.llm = new OpenAI({ 
+  model: "gpt-4.1-mini", 
+  temperature: 0.2 
+});
+
+// Set the default global embedModel
+Settings.embedModel = new OpenAIEmbedding({
+  model: "text-embedding-3-small",
+});
+
+// Sample documents
+const documents = [
+  new Document({
+    text: "LlamaIndex is a data framework for LLM applications to ingest, structure, and access private or domain-specific data.",
+  }),
+  new Document({
+    text: "LlamaIndex workflows are a lightweight workflow engine for TypeScript, designed to create event-driven processes.",
+  }),
+];
+
+// Create vector store index
+const index = await VectorStoreIndex.fromDocuments(documents);
+
+// Handle query: Retrieve relevant documents
+workflow.handle([queryEvent], (event) => {
+  const query = event.data;
+  console.log(`Processing query: ${query}`);
+  
+  // Retrieve relevant documents
+  const retriever = index.asRetriever();
+  const nodes = retriever.retrieve(query);
+  
+  return retrieveEvent.with({
+    query,
+    documents: nodes.map(node => node.node),
+  });
+});
+
+// Handle retrieval results: Generate response
+workflow.handle([retrieveEvent], async (event) => {
+  const { query, documents } = event.data;
+  
+  // Combine document content as context
+  const context = documents.map(doc => doc.text).join('\n\n');
+  
+  return generateEvent.with({ query, context });
+});
+
+// Handle generation: Produce final response
+workflow.handle([generateEvent], async (event) => {
+  const { query, context } = event.data;
+  
+  // Create a prompt with the context and query
+  const prompt = `
+Context information:
+${context}
+
+Based on the context information and no other knowledge, answer the following query:
+${query}
+  `;
+  
+  // Generate response with LLM
+  const response = await Settings.llm.complete({ prompt });
+  
+  return responseEvent.with(response.text);
+});
+
+// Execute the workflow
+const { stream, sendEvent } = workflow.createContext();
+sendEvent(queryEvent.with("What is LlamaIndex?"));
+
+// Process the stream
+for await (const event of stream) {
+  if (responseEvent.include(event)) {
+    console.log("Final response:", event.data);
+    break;
+  }
+}
+```
+
+## Building a Chat Application
+
+Let's create a more complex chat application that maintains conversation history:
+
+```ts
+import { createWorkflow, workflowEvent, withStore } from "llamaindex";
+import { OpenAI, OpenAIEmbedding } from "@llamaindex/openai";
+import { Document, serviceContextFromDefaults, VectorStoreIndex } from "llamaindex";
+import { Settings } from "@llamaindex/core/global"
+
+// Set default global llm
+Settings.llm = new OpenAI({ 
+  model: "gpt-4.1-mini", 
+  temperature: 0.2 
+});
+
+// Set the default global embedModel
+Settings.embedModel = new OpenAIEmbedding({
+  model: "text-embedding-3-small",
+});
+
+// Define store type
+type ChatStore = {
+  history: Array<{ role: string; content: string }>;
+  documents: Document[];
+  index: VectorStoreIndex | null;
+};
+
+// Define events
+const initEvent = workflowEvent<Document[]>();
+const indexCreatedEvent = workflowEvent<VectorStoreIndex>();
+const userMessageEvent = workflowEvent<string>();
+const retrievalEvent = workflowEvent<{ query: string; nodes: any[] }>();
+const responseEvent = workflowEvent<{ message: { content: string } }>();
+
+// Create workflow with store
+const workflow = withStore<ChatStore>(
+  () => ({
+    history: [],
+    documents: [],
+    index: null,
+  }),
+  createWorkflow()
+);
+
+// Initialize the chat context
+workflow.handle([initEvent], async (event) => {
+  const store = workflow.getStore();
+  store.documents = event.data;
+  
+  // Create index from documents
+  const index = await VectorStoreIndex.fromDocuments(store.documents);
+  
+  store.index = index;
+  return indexCreatedEvent.with(index);
+});
+
+// Process user message
+workflow.handle([userMessageEvent], (event) => {
+  const userMessage = event.data;
+  const store = workflow.getStore();
+  
+  // Add user message to history
+  store.history.push({
+    role: "user",
+    content: userMessage,
+  });
+  
+  if (!store.index) {
+    throw new Error("Index not initialized yet");
+  }
+  
+  // Retrieve relevant context
+  const retriever = store.index.asRetriever();
+  const nodes = retriever.retrieve(userMessage);
+  
+  return retrievalEvent.with({
+    query: userMessage,
+    nodes,
+  });
+});
+
+// Generate response from retrieval results
+workflow.handle([retrievalEvent], async (event) => {
+  const { query, nodes } = event.data;
+  const store = workflow.getStore();
+  
+  // Context from retrieved nodes
+  const context = nodes.map(node => node.node.text).join('\n\n');
+  
+  // Create the system message with context
+  const systemMessage = {
+    role: "system",
+    content: `You are a helpful assistant. Use the following information to answer the user's question:
+    
+${context}
+    
+Only use the information provided above to answer. If you don't know, say so.`,
+  };
+  
+  // Create full conversation history for the chat
+  const messages = [
+    systemMessage,
+    ...store.history,
+  ];
+  
+  // Generate response
+  const response = await Settings.llm.chat({
+    messages,
+  });
+  
+  // Add assistant response to history
+  store.history.push({
+    role: "assistant",
+    content: response.message.content,
+  });
+  
+  return responseEvent.with(response);
+});
+
+// Example usage
+async function runChat() {
+  // Sample documents
+  const documents = [
+    new Document({
+      text: "LlamaIndex is a data framework for LLM applications to ingest, structure, and access private or domain-specific data.",
+    }),
+    new Document({
+      text: "LlamaIndex Workflows are a lightweight workflow engine for TypeScript, designed to create event-driven processes.",
+    }),
+  ];
+  
+  // Initialize the chat
+  const { stream, sendEvent } = workflow.createContext();
+  sendEvent(initEvent.with(documents));
+  
+  // Wait for index creation
+  for await (const event of stream) {
+    if (indexCreatedEvent.include(event)) {
+      console.log("Index created successfully");
+      break;
+    }
+  }
+  
+  // Start conversation
+  async function sendUserMessage(message: string) {
+    sendEvent(userMessageEvent.with(message));
+    
+    for await (const event of stream) {
+      if (responseEvent.include(event)) {
+        console.log("Assistant:", event.data.message.content);
+        return event.data.message.content;
+      }
+    }
+  }
+  
+  await sendUserMessage("What is LlamaIndex?");
+  await sendUserMessage("Can you tell me about LlamaIndex workflows?");
+  await sendUserMessage("How might these two technologies work together?");
+}
+
+runChat();
+```
+
+## Building an Tool Calling Agent
+
+[TODO]
+
+## Conclusion
+
+By combining the lightweight, event-driven workflow engine with LlamaIndex's powerful document indexing and querying capabilities, you can build sophisticated AI applications with clean, maintainable code.
+
+The event-driven architecture allows you to:
+
+1. Break complex processes into manageable steps
+2. Create reusable components for common AI workflows
+3. Easily debug and monitor each phase of execution
+4. Scale your applications by isolating resource-intensive steps
+5. Build more resilient systems with better error handling
+
+As you build your own applications, consider how the patterns shown here can be adapted to your specific use cases. 

apps/next/src/content/docs/llamaindex/tutorials/workflow/meta.json

@@ -0,0 +1,12 @@
+{
+  "title": "Workflows",
+  "description": "Event-driven workflow engine for TypeScript",
+  "defaultOpen": false,
+  "pages": [
+    "index",
+    "basic-workflow",
+    "streaming",
+    "advanced-events",
+    "llamaindex-integration"
+  ]
+}

apps/next/src/content/docs/llamaindex/tutorials/workflow/streaming.mdx

@@ -0,0 +1,371 @@
+---
+title: Streaming with Workflows
+description: Learn how to build streaming workflows
+---
+
+LlamaIndex workflows are designed from the ground up to work with streaming data. The streaming capabilities make it perfect for:
+
+- Building real-time applications
+- Handling large datasets incrementally
+- Creating responsive UIs that update as data becomes available
+- Implementing long-running tasks with partial results
+
+## Basic Streaming
+
+Every workflow context provides a stream of events:
+
+```ts
+import { createWorkflow, workflowEvent } from "llamaindex";
+
+// Define events
+const startEvent = workflowEvent<string>();
+const intermediateEvent = workflowEvent<string>();
+const resultEvent = workflowEvent<string>();
+
+// Create workflow
+const workflow = createWorkflow();
+
+workflow.handle([startEvent], (event) => {
+  const { sendEvent } = getContext();
+  
+  // Emit multiple intermediate events
+  for (let i = 0; i < 5; i++) {
+    sendEvent(intermediateEvent.with(`Progress: ${i * 20}%`));
+  }
+  
+  return resultEvent.with("Completed");
+});
+
+// Run the workflow
+const { stream, sendEvent } = workflow.createContext();
+sendEvent(startEvent.with("Start processing"));
+
+// Process events as they arrive
+for await (const event of stream) {
+  if (intermediateEvent.include(event)) {
+    console.log(event.data); // Show progress updates
+  } else if (resultEvent.include(event)) {
+    console.log("Final result:", event.data);
+    break; // Exit the loop when done
+  }
+}
+```
+
+## Using the Stream Utilities
+
+Workflows provide utility functions to make working with streams easier:
+
+```ts
+import { createWorkflow, workflowEvent, until, collect } from "llamaindex";
+
+const startEvent = workflowEvent<void>();
+const progressEvent = workflowEvent<number>();
+const resultEvent = workflowEvent<string>();
+
+const workflow = createWorkflow();
+
+workflow.handle([startEvent], () => {
+  const { sendEvent } = getContext();
+  
+  // Emit progress events
+  for (let i = 0; i < 100; i += 10) {
+    sendEvent(progressEvent.with(i));
+  }
+  
+  return resultEvent.with("Complete");
+});
+
+// Run the workflow and collect events until a condition is met
+const { stream, sendEvent } = workflow.createContext();
+sendEvent(startEvent.with());
+
+// Collect all events until resultEvent is encountered
+const events = await collect(until(stream, (event) => resultEvent.include(event)));
+
+// Filter only progress events
+const progressEvents = events.filter(event => progressEvent.include(event));
+console.log(`Received ${progressEvents.length} progress updates`);
+```
+
+## Conditional Stream Processing
+
+You can conditionally process events and even stop the stream early:
+
+```ts
+import { createWorkflow, workflowEvent } from "llamaindex";
+
+const startEvent = workflowEvent<number>();
+const dataEvent = workflowEvent<number>();
+const thresholdEvent = workflowEvent<void>();
+const resultEvent = workflowEvent<number[]>();
+
+const workflow = createWorkflow();
+
+workflow.handle([startEvent], (event) => {
+  const { sendEvent } = getContext();
+  const max = event.data;
+  
+  for (let i = 0; i < max; i++) {
+    sendEvent(dataEvent.with(i));
+    if (i >= 10) {
+      // Signal that we've hit a threshold
+      sendEvent(thresholdEvent.with());
+    }
+  }
+  
+  return resultEvent.with(Array.from({ length: max }, (_, i) => i));
+});
+
+// Run the workflow
+const { stream, sendEvent } = workflow.createContext();
+sendEvent(startEvent.with(100)); // Generate 100 numbers
+
+const results = [];
+let hitThreshold = false;
+
+// Process the stream
+for await (const event of stream) {
+  if (dataEvent.include(event)) {
+    results.push(event.data);
+  } else if (thresholdEvent.include(event)) {
+    hitThreshold = true;
+    break; // Stop processing early
+  }
+}
+
+console.log(`Collected ${results.length} items before ${hitThreshold ? 'hitting threshold' : 'completion'}`);
+```
+
+## Integration with UI Frameworks
+
+Workflow streams can be easily integrated with UI frameworks like React to create responsive interfaces:
+
+```tsx
+// In a React component
+import { useEffect, useState } from 'react';
+import { createWorkflow, workflowEvent } from "llamaindex";
+
+function StreamingComponent() {
+  const [updates, setUpdates] = useState([]);
+  const [isComplete, setIsComplete] = useState(false);
+  
+  useEffect(() => {
+    // Set up workflow
+    const startEvent = workflowEvent<void>();
+    const updateEvent = workflowEvent<string>();
+    const completeEvent = workflowEvent<void>();
+    
+    const workflow = createWorkflow();
+    
+    workflow.handle([startEvent], () => {
+      const { sendEvent } = getContext();
+      
+      // Simulate async updates
+      const intervals = [
+        setTimeout(() => sendEvent(updateEvent.with("First update")), 500),
+        setTimeout(() => sendEvent(updateEvent.with("Second update")), 1000),
+        setTimeout(() => sendEvent(updateEvent.with("Final update")), 1500),
+        setTimeout(() => sendEvent(completeEvent.with()), 2000)
+      ];
+      
+      // Cleanup function
+      getContext().signal.onabort = () => {
+        intervals.forEach(clearTimeout);
+      };
+    });
+    
+    // Run the workflow
+    const { stream, sendEvent } = workflow.createContext();
+    sendEvent(startEvent.with());
+    
+    // Process events
+    const processEvents = async () => {
+      for await (const event of stream) {
+        if (updateEvent.include(event)) {
+          setUpdates(prev => [...prev, event.data]);
+        } else if (completeEvent.include(event)) {
+          setIsComplete(true);
+          break;
+        }
+      }
+    };
+    
+    processEvents();
+    
+    // Cleanup
+    return () => {
+      // The workflow will be aborted when the component unmounts
+    };
+  }, []);
+  
+  return (
+    <div>
+      <h2>Streaming Updates</h2>
+      <ul>
+        {updates.map((update, i) => (
+          <li key={i}>{update}</li>
+        ))}
+      </ul>
+      {isComplete && <div>Process complete!</div>}
+    </div>
+  );
+}
+```
+
+## Server-Sent Events (SSE)
+
+Workflows are also suitable for implementing Server-Sent Events:
+
+```ts
+import { createWorkflow, workflowEvent } from "llamaindex";
+import express from 'express';
+
+// Define events
+const startEvent = workflowEvent<void>();
+const dataEvent = workflowEvent<string>();
+
+// Create workflow
+const workflow = createWorkflow();
+
+workflow.handle([startEvent], () => {
+  const { sendEvent } = getContext();
+  
+  // Send periodic updates
+  const intervals = [
+    setInterval(() => {
+      sendEvent(dataEvent.with(`Update: ${new Date().toISOString()}`));
+    }, 1000)
+  ];
+  
+  // Cleanup
+  getContext().signal.onabort = () => {
+    intervals.forEach(clearInterval);
+  };
+});
+
+// Set up Express server
+const app = express();
+
+app.get('/events', (req, res) => {
+  // Set headers for SSE
+  res.setHeader('Content-Type', 'text/event-stream');
+  res.setHeader('Cache-Control', 'no-cache');
+  res.setHeader('Connection', 'keep-alive');
+  
+  // Run workflow
+  const { stream, sendEvent } = workflow.createContext();
+  sendEvent(startEvent.with());
+  
+  // Handle client disconnect
+  req.on('close', () => {
+    // This will trigger the abort signal in the workflow
+  });
+  
+  // Process and send events
+  (async () => {
+    for await (const event of stream) {
+      if (dataEvent.include(event)) {
+        res.write(`data: ${JSON.stringify(event.data)}\n\n`);
+      }
+    }
+  })();
+});
+
+app.listen(3000, () => {
+  console.log('SSE server running on port 3000');
+});
+```
+
+## Advanced Techniques
+
+### Flow Control
+
+You can implement flow control with backpressure in your streaming workflows:
+
+```ts
+import { createWorkflow, workflowEvent } from "llamaindex";
+
+// This example shows how to process items with controlled concurrency
+const processItems = async (items, maxConcurrency = 3) => {
+  const startEvent = workflowEvent<string[]>();
+  const processItemEvent = workflowEvent<string>();
+  const itemProcessedEvent = workflowEvent<string>();
+  const resultEvent = workflowEvent<string[]>();
+  
+  const workflow = createWorkflow();
+  
+  // Handler to process individual items
+  workflow.handle([processItemEvent], async (event) => {
+    // Simulate processing time
+    await new Promise(resolve => setTimeout(resolve, 100));
+    return itemProcessedEvent.with(`Processed: ${event.data}`);
+  });
+  
+  // Main workflow handler
+  workflow.handle([startEvent], async (event) => {
+    const { sendEvent, stream } = getContext();
+    const results = [];
+    
+    // Process with controlled concurrency
+    const items = event.data;
+    let inProgress = 0;
+    let itemIndex = 0;
+    
+    // Start initial batch of items
+    while (inProgress < maxConcurrency && itemIndex < items.length) {
+      sendEvent(processItemEvent.with(items[itemIndex++]));
+      inProgress++;
+    }
+    
+    // Process items and collect results
+    for await (const event of stream) {
+      if (itemProcessedEvent.include(event)) {
+        results.push(event.data);
+        inProgress--;
+        
+        // Add next item if available
+        if (itemIndex < items.length) {
+          sendEvent(processItemEvent.with(items[itemIndex++]));
+          inProgress++;
+        } else if (inProgress === 0) {
+          // All done
+          break;
+        }
+      }
+    }
+    
+    return resultEvent.with(results);
+  });
+  
+  // Run the workflow
+  const { stream, sendEvent } = workflow.createContext();
+  sendEvent(startEvent.with(items));
+  
+  // Wait for final result
+  for await (const event of stream) {
+    if (resultEvent.include(event)) {
+      return event.data;
+    }
+  }
+  
+  return [];
+};
+
+// Usage
+const results = await processItems(
+  Array.from({ length: 20 }, (_, i) => `Item ${i}`)
+);
+console.log(results);
+```
+
+This pattern allows you to:
+1. Process large datasets without overwhelming system resources
+2. Control the level of concurrency
+3. Process data as it becomes available
+4. Create efficient data pipelines
+
+## Next Steps
+
+Now that you've learned about streaming with workflows, explore more advanced topics:
+- [Advanced Event Handling](./advanced-events.mdx)
+- [Integration Workflows with other LlamaIndex features](./llamaindex-integration.mdx)

apps/next/src/content/docs/llamaindex/tutorials/workflows.mdx

@@ -1,176 +0,0 @@
----
-title: Workflows
----
-
-A `Workflow` in LlamaIndex is a lightweight, event-driven abstraction used to chain together several events. Workflows are made up of `handlers`, with each one responsible for processing specific event types and emitting new events.
-
-Workflows are designed to be flexible and can be used to build agents, RAG flows, extraction flows, or anything else you want to implement.
-
-```package-install
-npm i @llamaindex/workflow @llamaindex/openai
-```
-
-## Getting Started
-
-Let's explore a simple workflow example where a joke is generated and then critiqued and iterated on:
-
-<include cwd>../../examples/agents/workflow/joke.ts</include>
-
-There are a few moving pieces here, so let's go through this step by step.
-
-### Defining Workflow Events
-
-```typescript
-const startEvent = workflowEvent<string>(); // Input topic for joke
-const jokeEvent = workflowEvent<{ joke: string }>(); // Intermediate joke
-const critiqueEvent = workflowEvent<{ joke: string; critique: string }>(); // Intermediate critique
-const resultEvent = workflowEvent<{ joke: string; critique: string }>(); // Final joke + critique
-```
-
-Events are defined using the `workflowEvent` function and contain arbitrary data provided as a generic type. In this example, we have four events:
-- `startEvent`: Takes a string input (the joke topic)
-- `jokeEvent`: Contains an object with a joke property
-- `critiqueEvent`: Contains both the joke and its critique, used for the feedback loop
-- `resultEvent`: Contains the final joke and critique after any iterations
-
-### Setting up the Workflow with Stateful Middleware
-
-```typescript
-const { withState, getContext } = createStatefulMiddleware(() => ({
-  numIterations: 0,
-  maxIterations: 3,
-}));
-const jokeFlow = withState(createWorkflow());
-```
-
-Our workflow is implemented using the `createWorkflow()` function, enhanced with the `withState` middleware. This middleware provides shared state across all handlers, which in this case tracks:
-- `numIterations`: Counts how many iterations of joke improvement we've done
-- `maxIterations`: Sets a limit to prevent infinite loops
-
-This state will be accessible within workflows by using the `getContext().state` function.
-
-### Adding Handlers with Loops
-
-We have three key handlers in our workflow:
-
-1. The first handler processes the `startEvent`, generates an initial joke, and emits a `jokeEvent`:
-
-```typescript
-jokeFlow.handle([startEvent], async (event) => {
-  // Prompt the LLM to write a joke
-  const prompt = `Write your best joke about ${event.data}. Write the joke between <joke> and </joke> tags.`;
-  const response = await llm.complete({ prompt });
- 
-  // Parse the joke from the response
-  const joke =
-    response.text.match(/<joke>([\s\S]*?)<\/joke>/)?.[1]?.trim() ??
-    response.text;
-  return jokeEvent.with({ joke: joke });
-});
-```
-
-2. The second handler handles the `jokeEvent`, critiques the joke, and either:
-   - Emits a `critiqueEvent` if the joke needs improvement
-   - Emits a `resultEvent` if the joke is good enough
-
-```typescript
-jokeFlow.handle([jokeEvent], async (event) => {
-  // Prompt the LLM to critique the joke
-  const prompt = `Give a thorough critique of the following joke. If the joke needs improvement, put "IMPROVE" somewhere in the critique: ${event.data.joke}`;
-  const response = await llm.complete({ prompt });
- 
-  // If the critique includes "IMPROVE", keep iterating, else, return the result
-  if (response.text.includes("IMPROVE")) {
-    return critiqueEvent.with({
-      joke: event.data.joke,
-      critique: response.text,
-    });
-  }
- 
-  return resultEvent.with({ joke: event.data.joke, critique: response.text });
-});
-```
-
-3. The third handler processes the `critiqueEvent`, generates an improved joke based on the critique, and either:
-   - Loops back to the joke evaluation (if under the iteration limit)
-   - Emits the final `resultEvent` (if iteration limit reached)
-
-```typescript
-jokeFlow.handle([critiqueEvent], async (event) => {
-  // Keep track of the number of iterations
-  const state = getContext().state;
-  state.numIterations++;
- 
-  // Write a new joke based on the previous joke and critique
-  const prompt = `Write a new joke based on the following critique and the original joke. Write the joke between <joke> and </joke> tags.\n\nJoke: ${event.data.joke}\n\nCritique: ${event.data.critique}`;
-  const response = await llm.complete({ prompt });
- 
-  // Parse the joke from the response
-  const joke =
-    response.text.match(/<joke>([\s\S]*?)<\/joke>/)?.[1]?.trim() ??
-    response.text;
- 
-  // If we've done less than the max number of iterations, keep iterating
-  // else, return the result
-  if (state.numIterations < state.maxIterations) {
-    return jokeEvent.with({ joke: joke });
-  }
- 
-  return resultEvent.with({ joke: joke, critique: event.data.critique });
-});
-```
-
-### Running the Workflow
-
-```typescript
-async function main() {
-  const { stream, sendEvent } = jokeFlow.createContext();
-  sendEvent(startEvent.with("pirates"));
-
-  let result: { joke: string, critique: string } | undefined;
-
-  for await (const event of stream) {
-    // console.log(event.data);  optionally log the event data
-    if (resultEvent.include(event)) {
-      result = event.data;
-      break; // Stop when we get the final result
-    }
-  }
-  
-  console.log(result);
-}
-```
-
-To run the workflow, we:
-1. Create a workflow context with `createContext()`
-2. Trigger the initial event with `sendEvent()`
-3. Listen to the event stream and process events as they arrive
-4. Use `include()` to check if an event is of a specific type
-5. Break the loop when we receive our final result
-
-### Using Stream Utilities
-
-The `stream` returned by `createContext` contains utility functions to make working with event streams easier:
-
-```typescript
-// Create a workflow context and send the initial event
-const { stream, sendEvent } = jokeFlow.createContext();
-sendEvent(startEvent.with("pirates"));
-
-// Collect all events until we get a resultEvent
-const allEvents = await stream.until(resultEvent).toArray(); 
-
-// The last event will be the resultEvent
-const finalEvent = allEvents.at(-1);
-console.log(finalEvent.data); // Output the joke and critique
-```
-
-The stream utilities make it easier to work with the asynchronous event flow. In this example, we use:
-- `toArray`: Aggregates all events into an array
-- `until`: Creates a stream that emits events until a condition is met (in this case, until a resultEvent is received)
-
-You can combine these utilities with other stream operators like `filter` and `map` to create powerful processing pipelines.
-
-## Next Steps
-
-To learn more about workflows, check out [the Workflows documentation](/docs/llamaindex/modules/agents/workflows).

apps/next/src/content/docs/meta.json

@@ -1,3 +1,3 @@
 {
-  "pages": ["llamaindex", "api", "llamaflow"]
+  "pages": ["llamaindex", "llamaflow", "cloud", "api"]
 }

apps/next/src/deps/type.ts

@@ -0,0 +1,5 @@
+export type {
+  HandlerContext,
+  Workflow,
+  WorkflowContext,
+} from "@llamaindex/workflow";

apps/next/turbo.json

@@ -3,19 +3,12 @@
   "extends": ["//"],
   "tasks": {
     "build": {
-      "inputs": [
-        "node_modules/@llama-flow/docs/**",
-        "src/**/*.ts",
-        "src/**/*.tsx",
-        "src/**/*.mdx",
-        "src/**/*.md"
-      ],
       "outputs": [
         ".next",
         ".source",
         "next-env.d.ts",
-        "src/content/docs/api/**",
-        "tsconfig.json"
+        "src/content/docs/cloud/api/**",
+        "src/content/docs/api/**"
       ],
       "env": [
         "LLAMA_CLOUD_API_KEY",

apps/next/typedoc.json

@@ -2,10 +2,12 @@
   "plugin": ["typedoc-plugin-markdown", "typedoc-plugin-merge-modules"],
   "entryPoints": [
     "../../packages/{,**/}index.ts",
-    "../../packages/readers/src/*.ts"
+    "../../packages/readers/src/*.ts",
+    "../../packages/cloud/src/{reader,utils}.ts"
   ],
   "exclude": [
     "../../packages/autotool/**/src/index.ts",
+    "../../packages/cloud/src/client/index.ts",
     "**/node_modules/**",
     "**/dist/**",
     "**/test/**",
@@ -20,7 +22,7 @@
   "categoryOrder": ["Classes", "Enums", "Functions", "Interfaces", "Types"],
   "sort": ["source-order"],
   "entryFileName": "index.md",
-  "fileExtension": ".md",
+  "fileExtension": ".mdx",
   "hidePageTitle": true,
   "hidePageHeader": true,
   "hideGroupHeadings": true,

docs/llamaindexTS/getting_started/concepts.mdx

@@ -1,60 +0,0 @@
----
-title: High-Level Concepts
----
-
-This is a quick guide to the high-level concepts you'll encounter frequently when building LLM applications.
-
-## Large Language Models (LLMs)
-
-LLMs are the fundamental innovation that launched LlamaIndex. They are an artificial intelligence (AI) computer system that can understand, generate, and manipulate natural language, including answering questions based on their training data or data provided to them at query time. 
-
-## Agentic Applications
-
-When an LLM is used within an application, it is often used to make decisions, take actions, and/or interact with the world. This is the core definition of an **agentic application**.
-
-While the definition of an agentic application is broad, there are several key characteristics that define an agentic application:
-
-- **LLM Augmentation**: The LLM is augmented with tools (i.e. arbitrary callable functions in code), memory, and/or dynamic prompts.
-- **Prompt Chaining**: Several LLM calls are used that build on each other, with the output of one LLM call being used as the input to the next.
-- **Routing**: The LLM is used to route the application to the next appropriate step or state in the application.
-- **Parallelism**: The application can perform multiple steps or actions in parallel.
-- **Orchestration**: A hierarchical structure of LLMs is used to orchestrate lower-level actions and LLMs.
-- **Reflection**: The LLM is used to reflect and validate outputs of previous steps or LLM calls, which can be used to guide the application to the next appropriate step or state.
-
-In LlamaIndex, you can build agentic applications by using the workflows to orchestrate a sequence of steps and LLMs. You can [learn more about workflows](/docs/llamaindex/tutorials/workflows).
-
-## Agents
-
-We define an agent as a specific instance of an "agentic application". An agent is a piece of software that semi-autonomously performs tasks by combining LLMs with other tools and memory, orchestrated in a reasoning loop that decides which tool to use next (if any).
-
-What this means in practice, is something like:
-- An agent receives a user message
-- The agent uses an LLM to determine the next appropriate action to take using the previous chat history, tools, and the latest user message
-- The agent may invoke one or more tools to assist in the users request
-- If tools are used, the agent will then interpret the tool outputs and use them to inform the next action
-- Once the agent stops taking actions, it returns the final output to the user
-
-You can [learn more about agents](/docs/llamaindex/tutorials/basic_agent).
-
-## Retrieval Augmented Generation (RAG)
-
-Retrieval-Augmented Generation (RAG) is a core technique for building data-backed LLM applications with LlamaIndex. It allows LLMs to answer questions about your private data by providing it to the LLM at query time, rather than training the LLM on your data. To avoid sending **all** of your data to the LLM every time, RAG indexes your data and selectively sends only the relevant parts along with your query. You can [learn more about RAG](/docs/llamaindex/tutorials/rag).
-
-## Use cases
-
-There are endless use cases for data-backed LLM applications but they can be roughly grouped into four categories:
-
-[**Agents**](/docs/llamaindex/tutorials/basic_agent):
-An agent is an automated decision-maker powered by an LLM that interacts with the world via a set of [tools](/docs/llamaindex/modules/agents/tool). Agents can take an arbitrary number of steps to complete a given task, dynamically deciding on the best course of action rather than following pre-determined steps. This gives it additional flexibility to tackle more complex tasks.
-
-[**Workflows**](/docs/llamaindex/tutorials/workflows):
-A Workflow in LlamaIndex is a specific event-driven abstraction that allows you to orchestrate a sequence of steps and LLMs calls. Workflows can be used to implement any agentic application, and are a core component of LlamaIndex.
-
-[**Structured Data Extraction**](/docs/llamaindex/tutorials/structured_data_extraction):
-Pydantic extractors allow you to specify a precise data structure to extract from your data and use LLMs to fill in the missing pieces in a type-safe way. This is useful for extracting structured data from unstructured sources like PDFs, websites, and more, and is key to automating workflows.
-
-[**Query Engines**](/docs/llamaindex/modules/rag/query_engines):
-A query engine is an end-to-end flow that allows you to ask questions 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/rag/chat_engine):
-A chat engine is an end-to-end flow for having a conversation with your data (multiple back-and-forth instead of a single question-and-answer).

docs/llamaindexTS/getting_started/create_llama.mdx

@@ -1,21 +0,0 @@
----
-title: Create-Llama
----
-
-`create-llama` is a powerful but easy to use command-line tool that generates a working, full-stack web application that allows you to chat with your data. You can learn more about it on [the `create-llama` README page](https://www.npmjs.com/package/create-llama).
-
-Run it once and it will ask you a series of questions about the kind of application you want to generate. Then you can customize your application to suit your use-case. To get started, run:
-
-```bash npm2yarn
-npx create-llama@latest
-```
-
-Once your app is generated, `cd` into your app directory and run
-
-```bash npm2yarn
-npm run dev
-```
-
-to start the development server. You can then visit [http://localhost:3000](http://localhost:3000) to see your app, which should look something like this:
-
-![create-llama interface](/images/create_llama.png)

docs/llamaindexTS/getting_started/examples.mdx

@@ -1,32 +0,0 @@
----
-title: Code 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.
-
-## Use examples locally
-
-It may be useful to check out all the examples at once so you can try them out locally. To do this into a folder called `my-new-project`, run these commands:
-
-```bash npm2yarn
-npx degit run-llama/LlamaIndexTS/examples my-new-project
-cd my-new-project
-npm i
-```
-
-Then you can run any example in the folder with `tsx`, e.g.:
-
-```bash npm2yarn
-npx tsx ./vectorIndex.ts
-```
-
-## Try examples online
-
-You can also try the examples online using StackBlitz:
-
-<iframe
-  style={{ width: '100%', height: '440px' }}
-  aria-label="LlamaIndex.TS Examples"
-  aria-description="This is a list of examples for LlamaIndex.TS."
-  src="https://stackblitz.com/github/run-llama/LlamaIndexTS/tree/main/examples?file=README.md"
-/>

docs/llamaindexTS/getting_started/installation/cloudflare.mdx

@@ -1,72 +0,0 @@
----
-title: With Cloudflare Worker
-description: In this guide, you'll learn how to use LlamaIndex with CloudFlare Worker
----
-import { SiCloudflareworkers } from '@icons-pack/react-simple-icons';
-import { LinkCard, Aside } from '@astrojs/starlight/components';
-
-Before you start, make sure you have try LlamaIndex.TS in Node.js to make sure you understand the basics.
-
-<LinkCard
-  title="Getting Started with LlamaIndex.TS in Node.js"
-  href="/docs/llamaindex/getting_started/installation/node"
-/>
-
-Also, you need have the basic understanding of <a href='https://developers.cloudflare.com/workers/'><SiCloudflareworkers className="inline mr-2" color="#F38020" />Cloudflare Worker</a>.
-
-## Adding environment variables
-
-```ts
-export default {
-  async fetch(request: Request, env: Env): Promise<Response> {
-    const { setEnvs } = await import("@llamaindex/env");
-    setEnvs(env);
-    const { OpenAIAgent } = await import("@llamaindex/openai");
-    // Start your code here
-    return new Response("Hello, world!");
-  },
-};
-```
-
-Then, you need create `.dev.vars` and add LLM api keys for the local development, such as `OPENAI_API_KEY` for OpenAI API key.
-
-<Aside type="caution">Do not commit the api key to git repository.</Aside>
-
-## Integrating with Hono
-
-```ts
-import { Hono } from "hono";
-
-type Bindings = {
-  OPENAI_API_KEY: string;
-};
-
-const app = new Hono<{
-  Bindings: Bindings;
-}>();
-
-app.post("/llm", async (c) => {
-  const { setEnvs } = await import("@llamaindex/env");
-  setEnvs(c.env);
-
-  // ...
-
-  return new Response('Hello, world!');
-})
-
-export default {
-  fetch: app.fetch,
-};
-```
-
-## Difference between Node.js and Cloudflare Worker
-
-In Cloudflare Worker and similar serverless JS environment, you need to be aware of the following differences:
-
-- Some Node.js modules are not available in Cloudflare Worker, such as `node:fs`, `node:child_process`, `node:cluster`...
-- You are recommend to design your code using network request, such as use `fetch` API to communicate with database, instead of a long-running process in Node.js.
-- Some of LlamaIndex.TS packages are not available in Cloudflare Worker, for example `@llamaindex/readers` and `@llamaindex/huggingface`.
-- The main `llamaindex` is designed to work in all JavaScript environment, including Cloudflare Worker. If you find any issue, please report to us.
-- `@llamaindex/env` is a JS environment binding module, which polyfill some Node.js/Modern Web API (for example, we have a memory based `fs` module, and Crypto API polyfill). It is designed to work in all JavaScript environment, including Cloudflare Worker.
-
-

docs/llamaindexTS/getting_started/installation/index.mdx

@@ -1,63 +0,0 @@
----
-title: Installation
-description: How to install llamaindex packages.
----
-import { Card, CardGrid, LinkCard, Icon } from '@astrojs/starlight/components';
-import { SiTypescript, SiVite, SiCloudflareworkers, SiNodedotjs, SiNextdotjs } from '@icons-pack/react-simple-icons';
-
-To install llamaindex, run the following command:
-
-```package-install
-npm i llamaindex
-```
-
-In most cases, you'll also need an LLM package and the Workflow package to use LlamaIndex. For example, to use the OpenAI LLM with agents, you would install the following:
-
-```package-install
-npm i @llamaindex/openai @llamaindex/workflow
-```
-
-Go to [LLM APIs](/docs/llamaindex/modules/models/llms) to find out how to use other LLMs.
-
-
-## Frameworks
-
-LlamaIndex supports a wide range of frameworks and runtimes. Click on the card below to learn more.
-
-<CardGrid>
-	<LinkCard
-		title="Node.js"
-		href="/docs/llamaindex/getting_started/installation/node"
-	/>
-	<LinkCard
-		title="TypeScript"
-		href="/docs/llamaindex/getting_started/installation/typescript"
-	/>
-	<LinkCard
-		title="Vite"
-		href="/docs/llamaindex/getting_started/installation/vite"
-	/>
-	<LinkCard
-		title="Next.js"
-		href="/docs/llamaindex/getting_started/installation/next"
-	/>
-	<LinkCard
-		title="Cloudflare Workers"
-		href="/docs/llamaindex/getting_started/installation/cloudflare"
-	/>
-</CardGrid>
-
-## What's next?
-
-<CardGrid>
-	<LinkCard
-		title="Learn LlamaIndex.TS"
-		description="Learn how to use LlamaIndex.TS by starting with one of our tutorials."
-		href="/docs/llamaindex/tutorials/rag"
-	/>
-	<LinkCard
-		title="Show me code examples"
-		description="Explore code examples using LlamaIndex.TS."
-		href="/docs/llamaindex/getting_started/examples"
-	/>
-</CardGrid>

docs/llamaindexTS/getting_started/installation/meta.json

@@ -1,4 +0,0 @@
-{
-  "title": "Installation",
-  "pages": ["node", "typescript", "next", "vite", "cloudflare"]
-}

docs/llamaindexTS/getting_started/installation/next.mdx

@@ -1,42 +0,0 @@
----
-title: With Next.js
-description: In this guide, you'll learn how to use LlamaIndex with Next.js.
----
-import { Card, CardGrid, LinkCard, Icon } from '@astrojs/starlight/components';
-
-Before you start, make sure you have try LlamaIndex.TS in Node.js to make sure you understand the basics.
-
-<LinkCard
-  title="Getting Started with LlamaIndex.TS in Node.js"
-  href="/docs/llamaindex/getting_started/installation/node"
-/>
-
-## Differences between Node.js and Next.js
-
-Next.js is a React framework that has both server side compatibility and client side compatibility.
-This means that you need to be careful when using LlamaIndex.TS in Next.js.
-Don't leak the import data like API keys to the client side.
-
-Also, in Next.js, there is build time and runtime. Some computations can be done at build time like Document embedding could be done at build time for better performance.
-Where as the `llamaindex` package is working with Next.js, some provider packages like `@llamaindex/huggingface` are not working well with Next.js. This is due to the upstream dependencies used by the provider package. 
-
-Make sure to use `withLlamaIndex` to make sure that LlamaIndex.TS works well with Next.js.
-
-```js
-// next.config.mjs / next.config.ts
-import withLlamaIndex from "llamaindex/next";
-
-/** @type {import('next').NextConfig} */
-const nextConfig = {};
-
-export default withLlamaIndex(nextConfig);
-```
-
-If you see any dependency issues, you are welcome to open an issue on the GitHub.
-
-## Edge Runtime
-
-[Vercel Edge Runtime](https://edge-runtime.vercel.app/) is a subset of Node.js APIs. Similar to [Cloudflare Workers](/docs/llamaindex/getting_started/installation/cloudflare#difference-between-nodejs-and-cloudflare-worker),
-it is a serverless platform that runs your code on the edge.
-
-Not all features of Node.js are supported in Vercel Edge Runtime, so does LlamaIndex.TS, we are working on more compatibility with all JavaScript runtimes.

docs/llamaindexTS/getting_started/installation/node.mdx

@@ -1,41 +0,0 @@
----
-title: With Node.js/Bun/Deno
-description: In this guide, you'll learn how to use LlamaIndex with Node.js, Bun, and Deno.
----
-import { Card, CardGrid, LinkCard, Icon, Aside } from '@astrojs/starlight/components';
-
-## Adding environment variables
-
-By default, LlamaIndex uses OpenAI provider, which requires an API key. You can set the `OPENAI_API_KEY` environment variable to authenticate with OpenAI.
-
-```shell
-export OPENAI_API_KEY=your-api-key
-```
-
-Or you can use a `.env` file:
-
-```shell
-echo "OPENAI_API_KEY=your-api-key" > .env
-node --env-file .env your-script.js
-```
-
-<Aside type="caution">Do not commit the api key to git repository.</Aside>
-
-For more information, see the [How to read environment variables from Node.js](https://nodejs.org/en/learn/command-line/how-to-read-environment-variables-from-nodejs).
-
-## Performance Optimization
-
-By the default, we are using `js-tiktoken` for tokenization. You can install `gpt-tokenizer` which is then automatically used by LlamaIndex to get a 60x speedup for tokenization:
-
-```package-install
-npm i gpt-tokenizer
-```
-
-**Note**: This only works for Node.js
-
-## TypeScript support
-
-<LinkCard
-	title="Getting Started with LlamaIndex.TS in TypeScript"
-	href="/docs/llamaindex/getting_started/installation/typescript"
-/>

docs/llamaindexTS/getting_started/installation/typescript.mdx

@@ -1,99 +0,0 @@
----
-title: With TypeScript
-description: In this guide, you'll learn how to use LlamaIndex with TypeScript
----
-
-LlamaIndex.TS is written in TypeScript and designed to be used in TypeScript projects.
-
-We put a lot of work on strong typing to make sure you have a great typing experience with code completion such as:
-
-```ts twoslash
-import { PromptTemplate } from 'llamaindex'
-const promptTemplate = new PromptTemplate({
-  template: `Context information from multiple sources is below.
----------------------
-{context}
----------------------
-Given the information from multiple sources and not prior knowledge.
-Answer the query in the style of a Shakespeare play"
-Query: {query}
-Answer:`,
-	templateVars: ["context", "query"],
-});
-// @noErrors
-promptTemplate.format({
-	c
-//^|
-})
-```
-
-## Enable TypeScript
-
-Make sure to set [moduleResolution](https://www.typescriptlang.org/docs/handbook/modules/theory.html#module-resolution) in your `tsconfig.json` file:
-
-```json5
-{
-  compilerOptions: {
-    // ⬇️ add this line to your tsconfig.json
-    moduleResolution: "bundler", // or "nodenext" | "node16" | "node"
-  },
-}
-```
-
-We recommend using `bundler` or `nodenext`, but due to popularity of `node`, we still added support for it.
-
-## Enable AsyncIterable for `Web Stream` API
-
-Some modules uses `Web Stream` API like `ReadableStream` and `WritableStream`, you need to enable `DOM.AsyncIterable` in your `tsconfig.json`.
-
-```json5
-{
-  compilerOptions: {
-    // ⬇️ add this lib to your tsconfig.json
-    lib: ["DOM.AsyncIterable"],
-  },
-}
-```
-
-```typescript
-import { tool } from 'llamaindex'
-import { agent } from "@llamaindex/workflow";
-import { openai } from "@llamaindex/openai";
-
-Settings.llm = openai({
-  model: "gpt-4o-mini",
-});
-
-const addTool = tool({
-  name: "add", 
-  description: "Adds two numbers",
-  parameters: z.object({x: z.number(), y: z.number()}),
-  execute: ({ x, y }) => x + y,
-});
-
-const myAgent = agent({
-  tools: [addTool],
-});
-
-// Chat with the agent
-const context = myAgent.run("Hello, how are you?");
-
-for await (const event of context) {
-  if (event instanceof AgentStream) {
-    for (const chunk of event.data.delta) {
-      process.stdout.write(chunk); // stream response
-    }
-  } else {
-    console.log(event); // other events
-  }
-}
-
-```
-
-## Run TypeScript Script in Node.js
-
-We recommend to use [tsx](https://www.npmjs.com/package/tsx) to run TypeScript script in Node.js.
-
-```shell
-node --import tsx ./my-script.ts
-```

docs/llamaindexTS/getting_started/installation/vite.mdx

@@ -1,24 +0,0 @@
----
-title: With Vite
-description: In this guide, you'll learn how to use LlamaIndex with Vite
----
-import { Card, CardGrid, LinkCard, Icon, Aside } from '@astrojs/starlight/components';
-
-Before you start, make sure you have try LlamaIndex.TS in Node.js to make sure you understand the basics.
-
-<Card
-  title="Getting Started with LlamaIndex.TS in Node.js"
-  href="/docs/llamaindex/getting_started/installation/node"
-/>
-
-Also, make sure you have a basic understanding of [Vite](https://vitejs.dev/).
-
-## Why mention Vite?
-
-Vite.js is widely used in building many web applications, like React.js, even for some native app like [Electron](https://www.electronjs.org/).
-
-However, it's not a ready-to-use solution for a Node.js-like application using Vite, as Vite is designed for web applications(run in browser).
-
-There's some plugin/framework based on Vite, like [Waku.gg](https://github.com/dai-shi/waku), or [Electron Vite](https://electron-vite.org/)
-
-For now, we have no clear solution for bundling LlamaIndex.TS with Vite, if you have any idea/solution, please let us know.

docs/llamaindexTS/getting_started/meta.json

@@ -1,4 +0,0 @@
-{
-  "title": "Getting Started",
-  "pages": ["concepts", "installation", "create_llama", "examples"]
-}

docs/llamaindexTS/index.mdx

@@ -1,22 +0,0 @@
----
-title: What is LlamaIndex.TS
-description: LlamaIndex is the leading data framework for building LLM applications
----
-import { SiBun, SiCloudflareworkers, SiDeno, SiNodedotjs } from '@icons-pack/react-simple-icons';
-
-LlamaIndex is a framework for building context-augmented generative AI applications with LLMs including agents and workflows.
-
-The TypeScript implementation is designed for JavaScript server side applications using <SiNodedotjs className="inline" color="#5FA04E" /> Node.js, <SiDeno className="inline" color="#70FFAF" /> Deno, <SiBun className="inline" /> Bun, <SiCloudflareworkers className="inline" color="#F38020" /> Cloudflare Workers, and more.
-
-LlamaIndex.TS provides tools for beginners, advanced users, and everyone in between.
-
-Try it out with a starter example using StackBlitz:
-
-<iframe
-  style={{ width: '100%', height: '440px' }}
-  aria-label="LlamaIndex.TS Starter"
-  aria-description="This is a starter example for LlamaIndex.TS, it shows the basic usage of the library."
-  src="https://stackblitz.com/github/run-llama/LlamaIndexTS/tree/main/examples?embed=1&file=starter.ts"
-/>
-
-You'll need an OpenAI API key to run this example. You can retrieve it from [OpenAI](https://platform.openai.com/api-keys).

docs/llamaindexTS/integration/lang-trace.mdx

@@ -1,28 +0,0 @@
----
-title: Langtrace
-description: Learn how to integrate LlamaIndex.TS with Langtrace.
----
-
-Enhance your observability with Langtrace, a robust open-source tool supports OpenTelemetry and is designed to trace, evaluate, and manage LLM applications seamlessly. Langtrace integrates directly with LlamaIndex, offering detailed, real-time insights into performance metrics such as accuracy, evaluations, and latency.
-
-## Install
-
-- Self-host or sign-up and generate an API key using [Langtrace](https://www.langtrace.ai) Cloud
-
-```package-install
-npm i @langtrase/typescript-sdk
-```
-
-## Initialize
-
-```js
-import * as Langtrace from "@langtrase/typescript-sdk";
-Langtrace.init({ api_key: "<YOUR_API_KEY>" });
-```
-
-Features:
-
-- OpenTelemetry compliant, ensuring broad compatibility with observability platforms.
-- Provides comprehensive logs and detailed traces of all components.
-- Real-time monitoring of accuracy, evaluations, usage, costs, and latency.
-- For more configuration options and details, visit [Langtrace Docs](https://docs.langtrace.ai/introduction).

docs/llamaindexTS/integration/meta.json

@@ -1,5 +0,0 @@
-{
-  "title": "Integration",
-  "description": "See our integrations",
-  "pages": ["open-llm-metry", "lang-trace", "vercel"]
-}

docs/llamaindexTS/integration/open-llm-metry.mdx

@@ -1,22 +0,0 @@
----
-title: OpenLLMetry
-description: Learn how to integrate LlamaIndex.TS with OpenLLMetry.
----
-
-[OpenLLMetry](https://github.com/traceloop/openllmetry-js) is an open-source project based on OpenTelemetry for tracing and monitoring
-LLM applications. It connects to [all major observability platforms](https://www.traceloop.com/docs/openllmetry/integrations/introduction) and installs in minutes.
-
-### Usage Pattern
-
-```package-install
-npm i @traceloop/node-server-sdk
-```
-
-```js
-import * as traceloop from "@traceloop/node-server-sdk";
-
-traceloop.initialize({
-  apiKey: process.env.TRACELOOP_API_KEY,
-  disableBatch: true
-});
-```

docs/llamaindexTS/integration/vercel.mdx

@@ -1,102 +0,0 @@
----
-title: Vercel
-description: Integrate LlamaIndex with Vercel's AI SDK
----
-
-LlamaIndex provides integration with Vercel's AI SDK, allowing you to create powerful search and retrieval applications. You can:
-- Use any of Vercel AI's [model providers](https://sdk.vercel.ai/docs/foundations/providers-and-models) as LLMs in LlamaIndex
-- Use indexes (e.g. VectorStoreIndex, LlamaCloudIndex) from LlamaIndexTS in your Vercel AI applications
-
-## Setup
-
-First, install the required dependencies:
-
-```package-install
-npm i @llamaindex/vercel ai
-```
-
-## Using Vercel AI's Model Providers 
-
-Using the `VercelLLM` adapter, it's easy to use any of Vercel AI's [model providers](https://sdk.vercel.ai/docs/foundations/providers-and-models) as LLMs in LlamaIndex. Here's an example of how to use OpenAI's GPT-4o model:
-
-```typescript
-const llm = new VercelLLM({ model: openai("gpt-4o") });
-const result = await llm.complete({
-  prompt: "What is the capital of France?",
-  stream: false, // Set to true if you want streaming responses
-});
-console.log(result.text);
-```
-
-## Use Indexes
-
-### Using VectorStoreIndex
-
-Here's how to create a simple vector store index and query it using Vercel's AI SDK:
-
-```typescript
-import { openai } from "@ai-sdk/openai";
-import { llamaindex } from "@llamaindex/vercel";
-import { streamText } from "ai";
-import { Document, VectorStoreIndex } from "llamaindex";
-
-// Create an index from your documents
-const document = new Document({ text: yourText, id_: "unique-id" });
-const index = await VectorStoreIndex.fromDocuments([document]);
-
-// Create a query tool
-const queryTool = llamaindex({
-  model: openai("gpt-4"),
-  index,
-  description: "Search through the documents", // optional
-});
-
-// Use the tool with Vercel's AI SDK
-streamText({
-  model: openai("gpt-4"),
-  prompt: "Your question here",
-  tools: { queryTool },
-  onFinish({ response }) {
-    console.log("Response:", response.messages); // log the response
-  },
-}).toDataStream();
-```
-
-> Note: the Vercel AI model referenced in the `llamaindex` function is used by the response synthesizer to generate a response for the tool call.
-
-### Using LlamaCloud
-
-For production deployments, you can use LlamaCloud to store and manage your documents:
-
-```typescript
-import { LlamaCloudIndex } from "@llamaindex/cloud";
-
-// Create a LlamaCloud index
-const index = await LlamaCloudIndex.fromDocuments({
-  documents: [document],
-  name: "your-index-name",
-  projectName: "your-project",
-  apiKey: process.env.LLAMA_CLOUD_API_KEY,
-});
-
-// Use it the same way as VectorStoreIndex
-const queryTool = llamaindex({
-  model: openai("gpt-4"),
-  index,
-  description: "Search through the documents",
-  options: { fields: ["sourceNodes", "messages"]}
-});
-
-// Use the tool with Vercel's AI SDK
-streamText({
-  model: openai("gpt-4"),
-  prompt: "Your question here",
-  tools: { queryTool },
-}).toDataStream();
-```
-
-## Next Steps
-
-1. Explore [LlamaCloud](https://cloud.llamaindex.ai/) for managed document storage and retrieval
-2. Join our [Discord community](https://discord.gg/dGcwcsnxhU) for support and discussions
-

docs/llamaindexTS/meta.json

@@ -1,14 +0,0 @@
-{
-  "title": "LlamaIndex",
-  "description": "The Data framework for LLM",
-  "root": true,
-  "pages": [
-    "---Guide---",
-    "index",
-    "getting_started",
-    "tutorials",
-    "modules",
-    "integration",
-    "migration"
-  ]
-}

docs/llamaindexTS/migration/0.8-to-0.9.mdx

@@ -1,85 +0,0 @@
----
-title: Migrating from v0.8 to v0.9
----
-
-Version 0.9 of LlamaIndex.TS introduces significant architectural changes to improve package size and runtime compatibility. The main goals of this release are:
-
-1. Reduce the package size of the main `llamaindex` package by moving dependencies into provider packages, making it more suitable for serverless environments
-2. Enable consistent code across different environments by using unified imports (no separate imports for Node.js and Edge runtimes)
-
-## Major Changes
-
-### Installing Provider Packages
-
-In v0.9, you need to explicitly install the provider packages you want to use. The main `llamaindex` package no longer includes these dependencies by default.
-
-### Updating Imports
-
-You'll need to update your imports to get classes directly from their respective provider packages. Here's how to migrate different components:
-
-### 1. AI Model Providers
-
-Previously:
-```typescript
-import { OpenAI } from "llamaindex";
-```
-
-Now:
-```typescript
-import { OpenAI } from "@llamaindex/openai";
-```
-
-> Note: This examples requires installing the `@llamaindex/openai` package: 
-
-```package-install
-npm i @llamaindex/openai
-```
-
-For more details on available AI model providers and their configuration, see the [LLMs documentation](/docs/llamaindex/modules/models/llms) and the [Embedding Models documentation](/docs/llamaindex/modules/models/embeddings).
-
-### 2. Storage Providers
-
-Previously:
-```typescript
-import { PineconeVectorStore } from "llamaindex";
-```
-
-Now:
-```typescript
-import { PineconeVectorStore } from "@llamaindex/pinecone";
-```
-
-For more information about available storage options, refer to the [Data Stores documentation](/docs/llamaindex/modules/data/stores).
-
-### 3. Data Loaders
-
-Previously:
-```typescript
-import { SimpleDirectoryReader } from "llamaindex";
-```
-
-Now:
-```typescript
-import { SimpleDirectoryReader } from "@llamaindex/readers/directory";
-```
-
-For more details about available data loaders and their usage, check the [Loading Data](/docs/llamaindex/modules/data/readers).
-
-### 4. Prefer using `llamaindex` instead of `@llamaindex/core`
-
-`llamaindex` is now re-exporting most of `@llamaindex/core`. To simplify imports, just use `import { ... } from "llamaindex"` instead of `import { ... } from "@llamaindex/core"`. This is possible because `llamaindex` is now a smaller package.
-
-We might change imports internally in `@llamaindex/core` in the future. Let us know if you're missing something. 
-
-## Benefits of the Changes
-
-- **Smaller Bundle Size**: By moving dependencies to separate packages, your application only includes the features you actually use
-- **Runtime Consistency**: The same code works across different environments without environment-specific imports
-- **Improved Serverless Support**: Reduced package size makes it easier to deploy to serverless environments with size limitations
-
-## Need Help?
-
-If you encounter any issues during migration, please:
-1. Check our [GitHub repository](https://github.com/run-llama/LlamaIndexTS) for the latest updates
-2. Join our [Discord community](https://discord.gg/dGcwcsnxhU) for support
-3. Open an issue on GitHub if you find a bug or have a feature request

docs/llamaindexTS/migration/deprecated/agent/index.mdx

@@ -1,28 +0,0 @@
----
-title: Agents
----
-
-**Note**: Agents are deprecated, use [Agent Workflows](/docs/llamaindex/modules/agents/agent_workflow) instead.
-
-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:
-
-- Breaking down a complex question into smaller ones
-- Choosing an external Tool to use + coming up with parameters for calling the Tool
-- Planning out a set of tasks
-- Storing previously completed tasks in a memory module
-
-## Getting Started
-
-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 both via Anthropic and Bedrock (in `@llamaIndex/community`)
-- Gemini Agent
-- ReACT Agent
-- Meta3.1 504B via Bedrock (in `@llamaIndex/community`)
-
-## Api References
-
-- [OpenAIAgent](/docs/api/classes/OpenAIAgent)
-- [AnthropicAgent](/docs/api/classes/AnthropicAgent)
-- [ReActAgent](/docs/api/classes/ReActAgent)

docs/llamaindexTS/migration/meta.json

@@ -1,5 +0,0 @@
-{
-  "title": "Migration",
-  "description": "Migration between different versions",
-  "pages": ["0.8-to-0.9", "deprecated"]
-}

docs/llamaindexTS/modules/agents/agent_workflow.mdx

@@ -1,118 +0,0 @@
----
-title: Agent Workflows
----
-
-
-Agent Workflows are a powerful system that enables you to create and orchestrate one or multiple agents with tools to perform specific tasks. It's built on top of the base [`Workflow`](/docs/llamaindex/modules/agents/workflows) system and provides a streamlined interface for agent interactions.
-
-## Usage
-
-### Single Agent Workflow
-
-The simplest use case is creating a single agent with specific tools. Here's an example of creating an assistant that tells jokes:
-
-```typescript
-import { tool } from "llamaindex";
-import { agent } from "@llamaindex/workflow";
-import { openai } from "@llamaindex/openai";
-
-// Define a joke-telling tool
-const jokeTool = tool(
-  () => "Baby Llama is called cria",
-  {
-    name: "joke",
-    description: "Use this tool to get a joke",
-  }
-);
-
-// Create an single agent workflow with the tool
-const jokeAgent = agent({
-  tools: [jokeTool],
-  llm: openai({ model: "gpt-4o-mini" }),
-});
-
-// Run the workflow
-const result = await jokeAgent.run("Tell me something funny");
-console.log(result); // Baby Llama is called cria
-```
-
-### Event Streaming
-
-Agent Workflows provide a unified interface for event streaming, making it easy to track and respond to different events during execution:
-
-```typescript
-import { agentToolCallEvent, agentStreamEvent } from "@llamaindex/workflow";
-
-// Get the workflow execution context
-const events = workflow.runStream("Tell me something funny");
-
-// Stream and handle events
-for await (const event of events) {
-  if (agentToolCallEvent.include(event)) {
-    console.log(`Tool being called: ${event.data.toolName}`);
-  }
-  if (agentStreamEvent.include(event)) {
-    process.stdout.write(event.data.delta);
-  }
-}
-```
-
-### Multi-Agent Workflow
-
-An Agent Workflow can orchestrate multiple agents, enabling complex interactions and task handoffs. Each agent in a multi-agent workflow requires:
-
-- `name`: Unique identifier for the agent
-- `description`: Purpose description used for task routing
-- `tools`: Array of tools the agent can use
-- `canHandoffTo` (optional): Array of agent names or agent instances that this agent can delegate tasks to
-
-Here's an example of a multi-agent system that combines joke-telling and weather information:
-
-```typescript
-import { tool } from "llamaindex";
-import { multiAgent, agent } from "@llamaindex/workflow";
-import { openai } from "@llamaindex/openai";
-import { z } from "zod";
-
-// Create a weather agent
-const weatherAgent = agent({
-  name: "WeatherAgent",
-  description: "Provides weather information for any city",
-  tools: [
-    tool(
-      {
-        name: "fetchWeather",
-        description: "Get weather information for a city",
-        parameters: z.object({
-          city: z.string(),
-        }),
-        execute: ({ city }) => `The weather in ${city} is sunny`,
-      }
-    ),
-  ],
-  llm: openai({ model: "gpt-4o-mini" }),
-});
-
-// Create a joke-telling agent
-const jokeAgent = agent({
-  name: "JokeAgent",
-  description: "Tells jokes and funny stories",
-  tools: [jokeTool], // Using the joke tool defined earlier
-  llm: openai({ model: "gpt-4o-mini" }),
-  canHandoffTo: [weatherAgent], // Can hand off to the weather agent
-});
-
-// Create the multi-agent workflow
-const agents = multiAgent({
-  agents: [jokeAgent, weatherAgent],
-  rootAgent: jokeAgent, // Start with the joke agent
-});
-
-// Run the workflow
-const result = await agents.run(
-  "Give me a morning greeting with a joke and the weather in San Francisco"
-);
-```
-
-The workflow will coordinate between agents, allowing them to handle different aspects of the request and hand off tasks when appropriate.
-

docs/llamaindexTS/modules/agents/meta.json

@@ -1,4 +0,0 @@
-{
-  "title": "Agents",
-  "pages": ["tool", "agent_workflow", "workflows"]
-}

docs/llamaindexTS/modules/agents/tool/index.mdx

@@ -1,144 +0,0 @@
----
-title: Tools
----
-
-A "tool" is a utility that can be called by an agent on behalf of an LLM.
-A tool can be called to perform custom actions, or retrieve extra information based on the LLM-generated input.
-A result from a tool call can be used by subsequent steps in a workflow, or to compute a final answer.
-For example, a "weather tool" could fetch some live weather information from a geographical location.
-
-## Tool Function
-
-The `tool` function is a utility provided to define a tool that can be used by an agent. It takes a function and a configuration object as arguments. The configuration object includes the tool's name, description, and parameters.
-
-### Parameters with Zod
-
-The `parameters` field in the tool configuration is defined using `zod`, a TypeScript-first schema declaration and validation library. `zod` allows you to specify the expected structure and types of the input parameters, ensuring that the data passed to the tool is valid.
-
-Example:
-```ts
-import { tool } from "llamaindex";
-import { agent } from "@llamaindex/workflow";
-import { z } from "zod";
-
-// first arg is LLM input, second is bound arg
-const queryKnowledgeBase = async ({ question }, { userToken }) => {
-  const response = await fetch(`https://knowledge-base.com?token=${userToken}&query=${question}`);
-  // ...
-};
-
-// define tool with zod validation
-const kbTool = tool(queryKnowledgeBase, {
-  name: 'queryKnowledgeBase',
-  description: 'Query knowledge base',
-  parameters: z.object({
-    question: z.string({
-      description: 'The user question',
-    }),
-  }),
-});
-
-```
-In this example, `z.object` is used to define a schema for the `parameters` where `question` is expected to be a string. This ensures that any input to the tool adheres to the specified structure, providing a layer of type safety and validation.
-
-
-## Built-in tools
-
-You can import built-in tools from the `@llamaindex/tools` package.
-
-```ts
-import { agent } from "@llamaindex/workflow";
-import { wiki } from "@llamaindex/tools";
-
-const researchAgent = agent({
-  name: "WikiAgent",
-  description: "Gathering information from the internet",
-  systemPrompt: `You are a research agent. Your role is to gather information from the internet using the provided tools.`,
-  tools: [wiki()],
-});
-```
-
-## MCP tools
-
-If you have a MCP server running, you can fetch tools from the server and use them in your agents.
-
-```ts
-// 1. Import MCP tools adapter
-import { mcp } from "@llamaindex/tools";
-import { agent } from "@llamaindex/workflow";
-
-// 2. Initialize a MCP client
-// by npx
-const server = mcp({
-  command: "npx",
-  args: ["-y", "@modelcontextprotocol/server-filesystem", "."],
-  verbose: true,
-});
-// or by SSE
-const server = mcp({
-  url: "http://localhost:8000/mcp",
-  verbose: true,
-});
-
-// 3. Get tools from MCP server
-const tools = await server.tools();
-
-// Now you can create an agent with the tools
-const agent = agent({
-  name: "My Agent",
-  systemPrompt: "You are a helpful assistant that can use the provided tools to answer questions.",
-  llm: openai({ model: "gpt-4o" }),
-  tools: tools,
-});
-```
-
-
-## Function tool
-
-You can still use the `FunctionTool` class to define a tool.
-A `FunctionTool` is constructed from a function with signature
-```ts
-(input: T, additionalArg?: AdditionalToolArgument) => R
-```
-where
-- `input` is generated by the LLM, `T` is the type defined by the tool `parameters`
-- `additionalArg` is an optional extra argument, see "Binding" below
-- `R` is the return type
-
-### Binding
-
-An additional argument can be bound to a tool, each tool call will be passed
-- the input provided by the LLM
-- the additional argument (extends object)
-
-Note: calling the `bind` method will return a new `FunctionTool` instance, without modifying the tool which `bind` is called on.
-
-Example to pass a `userToken` as additional argument:
-```ts
-import { tool } from "llamaindex";
-import { agent } from "@llamaindex/workflow";
-
-// first arg is LLM input, second is bound arg
-const queryKnowledgeBase = async ({ question }, { userToken }) => {
-  const response = await fetch(`https://knowledge-base.com?token=${userToken}&query=${question}`);
-  // ...
-};
-
-// define tool as usual
-const kbTool = tool(queryKnowledgeBase, {
-  name: 'queryKnowledgeBase',
-  description: 'Query knowledge base',
-  parameters: z.object({
-    question: z.string({
-      description: 'The user question',
-    }),
-  }),
-});
-
-// create an agent
-const additionalArg = { userToken: 'abcd1234' };
-const workflow = agent({
-  tools: [kbTool.bind(additionalArg)],
-  // llm, systemPrompt etc
-})
-```

docs/llamaindexTS/modules/agents/workflows.mdx

@@ -1,18 +0,0 @@
----
-title: Workflows
----
-
-A `Workflow` in LlamaIndex is a lightweight, event-driven abstraction used to chain together several events. Workflows are made up of `handlers`, with each one responsible for processing specific event types and emitting new events.
-
-Workflows are designed to be flexible and can be used to build agents, RAG flows, extraction flows, or anything else you want to implement.
-
-To use workflows install this package:
-
-```package-install
-npm i @llamaindex/workflow
-```
-
-This package is a stable, production-ready version of our [llama-flow](/docs/llamaflow) project. 
-
-While you can still reference the llama-flow documentation for detailed information about the underlying concepts, we recommend using the `@llamaindex/workflow` package for all new projects to ensure stability and long-term availability.
-

docs/llamaindexTS/modules/data/data_index/index.mdx

@@ -1,24 +0,0 @@
----
-title: Index
----
-
-An index is the basic container for organizing your data. Besides managed indexes using [LlamaCloud](/docs/llamaindex/modules/data/data_index/managed), LlamaIndex.TS supports three indexes:
-
-
-- `VectorStoreIndex` - will send the top-k `Node`s to the LLM when generating a response. The default top-k is 2.
-- `SummaryIndex` - will send every `Node` in the index to the LLM in order to generate a response
-- `KeywordTableIndex` extracts and provides keywords from `Node`s to the LLM
-
-```typescript
-import { Document, VectorStoreIndex } from "llamaindex";
-
-const document = new Document({ text: "test" });
-
-const index = await VectorStoreIndex.fromDocuments([document]);
-```
-
-## API Reference
-
-- [SummaryIndex](/docs/api/classes/SummaryIndex)
-- [VectorStoreIndex](/docs/api/classes/VectorStoreIndex)
-- [KeywordTableIndex](/docs/api/classes/KeywordTableIndex)

docs/llamaindexTS/modules/data/data_index/managed.mdx

@@ -1,32 +0,0 @@
----
-title: Managed Index
-description: Managed index using 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.
-
-LlamaCloud supports
-
-- Managed Ingestion API, handling parsing and document management
-- Managed Retrieval API, configuring optimal retrieval for your RAG system
-
-## Access
-
-Visit [LlamaCloud](https://cloud.llamaindex.ai) to sign in and get an API key.
-
-## Create a Managed Index
-
-Here's an example of how to create a managed index by ingesting a couple of documents:
-
-<include cwd>../../examples/cloud/chat.ts</include>
-
-## Use a Managed Index
-
-Here's an example of how to use a managed index together with a chat engine:
-
-<include cwd>../../examples/cloud/from-documents.ts</include>
-
-## API Reference
-
-- [LlamaCloudIndex](/docs/api/classes/LlamaCloudIndex)
-- [LlamaCloudRetriever](/docs/api/classes/LlamaCloudRetriever)

docs/llamaindexTS/modules/data/index.mdx

@@ -1,17 +0,0 @@
----
-title: Documents and Nodes
-description: Data structure for storing data in LlamaIndex
----
-
-`Document`s and `Node`s are the basic building blocks of data in LlamaIndexTS. 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.
-
-```typescript
-import { Document } from "llamaindex";
-
-document = new Document({ text: "text", metadata: { key: "val" } });
-```
-
-## API Reference
-
-- [Document](/docs/api/classes/Document)
-- [TextNode](/docs/api/classes/TextNode)

docs/llamaindexTS/modules/data/ingestion_pipeline/index.mdx

@@ -1,110 +0,0 @@
----
-title: 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).
-
-## Installation
-
-```package-install
-npm i llamaindex @llamaindex/openai @llamaindex/qdrant
-```
-
-## Usage Pattern
-
-The simplest usage is to instantiate an IngestionPipeline like so:
-
-```ts
-import fs from "node:fs/promises";
-import { OpenAI, OpenAIEmbedding } from "@llamaindex/openai";
-import {
-  Document,
-  IngestionPipeline,
-  MetadataMode,
-  TitleExtractor,
-  SentenceSplitter,
-} from "llamaindex";
-
-async function main() {
-  // Load essay from abramov.txt in Node
-  const path = "node_modules/llamaindex/examples/abramov.txt";
-
-  const essay = await fs.readFile(path, "utf-8");
-
-  // Create Document object with essay
-  const document = new Document({ text: essay, id_: path });
-  const pipeline = new IngestionPipeline({
-    transformations: [
-      new SentenceSplitter({ chunkSize: 1024, chunkOverlap: 20 }),
-      new TitleExtractor(),
-      new OpenAIEmbedding(),
-    ],
-  });
-
-  // run the pipeline
-  const nodes = await pipeline.run({ documents: [document] });
-
-  // print out the result of the pipeline run
-  for (const node of nodes) {
-    console.log(node.getContent(MetadataMode.NONE));
-  }
-}
-
-main().catch(console.error);
-```
-
-## Connecting to Vector Databases
-
-When running an ingestion pipeline, you can also chose to automatically insert the resulting nodes into a remote vector store.
-
-Then, you can construct an index from that vector store later on.
-
-```ts
-import fs from "node:fs/promises";
-
-import { OpenAIEmbedding } from "@llamaindex/openai";
-import { QdrantVectorStore } from "@llamaindex/qdrant";
-import {
-  Document,
-  IngestionPipeline,
-  MetadataMode,
-  TitleExtractor,
-  SentenceSplitter,
-  VectorStoreIndex,
-} from "llamaindex";
-
-async function main() {
-  // Load essay from abramov.txt in Node
-  const path = "node_modules/llamaindex/examples/abramov.txt";
-
-  const essay = await fs.readFile(path, "utf-8");
-
-  const vectorStore = new QdrantVectorStore({
-    host: "http://localhost:6333",
-  });
-
-  // Create Document object with essay
-  const document = new Document({ text: essay, id_: path });
-  const pipeline = new IngestionPipeline({
-    transformations: [
-      new SentenceSplitter({ chunkSize: 1024, chunkOverlap: 20 }),
-      new TitleExtractor(),
-      new OpenAIEmbedding(),
-    ],
-    vectorStore,
-  });
-
-  // run the pipeline
-  const nodes = await pipeline.run({ documents: [document] });
-
-  // create an index
-  const index = VectorStoreIndex.fromVectorStore(vectorStore);
-}
-
-main().catch(console.error);
-```
-
-## API Reference
-
-- [IngestionPipeline](/docs/api/classes/IngestionPipeline)

docs/llamaindexTS/modules/data/ingestion_pipeline/transformations/index.mdx

@@ -1,83 +0,0 @@
----
-title: 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/llamaindex/modules/data/ingestion_pipeline/transformations/node-parser)
-- [MetadataExtractor](/docs/llamaindex/modules/data/ingestion_pipeline/transformations/metadata_extraction)
-- [Embeddings](/docs/llamaindex/modules/models/embeddings)
-
-## Usage Pattern
-
-While transformations are best used with with an IngestionPipeline, they can also be used directly.
-
-```ts
-import { SentenceSplitter, TitleExtractor, Document } from "llamaindex";
-
-async function main() {
-  let nodes = new SentenceSplitter().getNodesFromDocuments([
-    new Document({ text: "I am 10 years old. John is 20 years old." }),
-  ]);
-
-  const titleExtractor = new TitleExtractor();
-
-  nodes = await titleExtractor.transform(nodes);
-
-  for (const node of nodes) {
-    console.log(node.getContent(MetadataMode.NONE));
-  }
-}
-
-main().catch(console.error);
-```
-
-## Custom Transformations
-
-You can implement any transformation yourself by implementing the `TransformComponent`.
-
-The following custom transformation will remove any special characters or punctuation in text.
-
-```ts
-import { TransformComponent, TextNode } from "llamaindex";
-
-export class RemoveSpecialCharacters extends TransformComponent {
-  async transform(nodes: TextNode[]): Promise<TextNode[]> {
-    for (const node of nodes) {
-      node.text = node.text.replace(/[^\w\s]/gi, "");
-    }
-
-    return nodes;
-  }
-}
-```
-
-These can then be used directly or in any IngestionPipeline.
-
-```ts
-import { IngestionPipeline, Document } from "llamaindex";
-
-async function main() {
-  const pipeline = new IngestionPipeline({
-    transformations: [new RemoveSpecialCharacters()],
-  });
-
-  const nodes = await pipeline.run({
-    documents: [
-      new Document({ text: "I am 10 years old. John is 20 years old." }),
-    ],
-  });
-
-  for (const node of nodes) {
-    console.log(node.getContent(MetadataMode.NONE));
-  }
-}
-
-main().catch(console.error);
-```
-
-## API Reference
-
-- [TransformComponent](/docs/api/classes/TransformComponent)

docs/llamaindexTS/modules/data/ingestion_pipeline/transformations/metadata_extraction.mdx

@@ -1,49 +0,0 @@
----
-title: Metadata Extraction 
----
-
-You can use LLMs to automate metadata extraction with our `Metadata Extractor` modules.
-
-Our metadata extractor modules include the following "feature extractors":
-
-- `SummaryExtractor` - automatically extracts a summary over a set of Nodes
-- `QuestionsAnsweredExtractor` - extracts a set of questions that each Node can answer
-- `TitleExtractor` - extracts a title over the context of each Node by document and combine them
-- `KeywordExtractor` - extracts keywords over the context of each Node
-
-Then you can chain the `Metadata Extractors` with the `IngestionPipeline` to extract metadata from a set of documents.
-
-```ts
-import { Document, IngestionPipeline, TitleExtractor, QuestionsAnsweredExtractor } from "llamaindex";
-import { OpenAI } from "@llamaindex/openai";
-
-async function main() {
-  const pipeline = new IngestionPipeline({
-    transformations: [
-      new TitleExtractor(),
-      new QuestionsAnsweredExtractor({
-        questions: 5,
-      }),
-    ],
-  });
-
-  const nodes = await pipeline.run({
-    documents: [
-      new Document({ text: "I am 10 years old. John is 20 years old." }),
-    ],
-  });
-
-  for (const node of nodes) {
-    console.log(node.metadata);
-  }
-}
-
-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)

docs/llamaindexTS/modules/data/ingestion_pipeline/transformations/node-parser.mdx

@@ -1,193 +0,0 @@
----
-title: Node Parsers / Text Splitters
-description: Learn how to use Node Parsers and Text Splitters to extract data from documents.
----
-import { Tabs, TabItem } from '@astrojs/starlight/components';
-
-Node parsers are a simple abstraction that take a list of `Document` objects, and chunk them into `Node` objects, such that each node is a specific chunk of the parent document. When a document is broken into nodes, all of it's attributes are inherited to the children nodes (i.e. `metadata`, text and metadata templates, etc.). You can read more about `Node` and `Document` properties [here](/docs/llamaindex/modules/data).
-
-By default, we will use `Settings.nodeParser` to split the document into nodes. You can also assign a custom `NodeParser` to the `Settings` object.
-
-## SentenceSplitter
-
-The `SentenceSplitter` is the default `NodeParser` in LlamaIndex. It will split the text from a `Document` into sentences.
-
-```ts twoslash
-import { TextFileReader } from '@llamaindex/readers/text'
-import { SentenceSplitter } from 'llamaindex';
-import { Settings } from 'llamaindex';
-
-const nodeParser = new SentenceSplitter();
-Settings.nodeParser = nodeParser;
-//		     ^?
-```
-
-The underlying text splitter will split text by sentences. It can also be used as a standalone module for splitting raw text.
-
-```ts twoslash
-import { SentenceSplitter } from "llamaindex";
-
-const splitter = new SentenceSplitter({ chunkSize: 1 });
-
-const texts = splitter.splitText("Hello World");
-//     ^?
-```
-
-## MarkdownNodeParser
-
-The `MarkdownNodeParser` is a more advanced `NodeParser` that can handle markdown documents. It will split the markdown into nodes and then parse the nodes into a `Document` object.
-
-<Tabs>
-	<TabItem label="with reader">
-	```ts twoslash
-	import { MarkdownNodeParser } from "llamaindex";
-	import { MarkdownReader } from '@llamaindex/readers/markdown'
-
-	const reader = new MarkdownReader();
-	const markdownNodeParser = new MarkdownNodeParser();
-
-	const documents = await reader.loadData('path/to/file.md');
-	const parsedDocuments = markdownNodeParser(documents);
-	//      ^?
-
-	```
-	</TabItem>
-	<TabItem label="with node:fs">
-	```ts twoslash tab="with node:fs"
-	import fs from 'node:fs/promises';
-	import { MarkdownNodeParser, Document } from "llamaindex";
-
-	const markdownNodeParser = new MarkdownNodeParser();
-	const text = await fs.readFile('path/to/file.md', 'utf-8');
-	const document = new Document({ text });
-
-	const parsedDocuments = markdownNodeParser([document]);
-	//		  ^?
-
-	```
-	</TabItem>
-</Tabs>
-
-The output metadata will be something like:
-
-```bash
-[
-  TextNode {
-    id_: '008e41a8-b097-487c-bee8-bd88b9455844',
-    metadata: { 'Header 1': 'Main Header' },
-    excludedEmbedMetadataKeys: [],
-    excludedLlmMetadataKeys: [],
-    relationships: { PARENT: [Array] },
-    hash: 'KJ5e/um/RkHaNR6bonj9ormtZY7I8i4XBPVYHXv1A5M=',
-    text: 'Main Header\nMain content',
-    textTemplate: '',
-    metadataSeparator: '\n'
-  },
-  TextNode {
-    id_: '0f5679b3-ba63-4aff-aedc-830c4208d0b5',
-    metadata: { 'Header 1': 'Header 2' },
-    excludedEmbedMetadataKeys: [],
-    excludedLlmMetadataKeys: [],
-    relationships: { PARENT: [Array] },
-    hash: 'IP/g/dIld3DcbK+uHzDpyeZ9IdOXY4brxhOIe7wc488=',
-    text: 'Header 2\nHeader 2 content',
-    textTemplate: '',
-    metadataSeparator: '\n'
-  },
-  TextNode {
-    id_: 'e81e9bd0-121c-4ead-8ca7-1639d65fdf90',
-    metadata: { 'Header 1': 'Header 2', 'Header 2': 'Sub-header' },
-    excludedEmbedMetadataKeys: [],
-    excludedLlmMetadataKeys: [],
-    relationships: { PARENT: [Array] },
-    hash: 'B3kYNnxaYi9ghtAgwza0ZEVKF4MozobkNUlcekDL7JQ=',
-    text: 'Sub-header\nSub-header content',
-    textTemplate: '',
-    metadataSeparator: '\n'
-  }
-]
-```
-
-## CodeSplitter
-
-The `CodeSplitter` is a more advanced `NodeParser` that can handle code documents.
-It will split the code by AST nodes and then parse the nodes into a `Document` object.
-
-<Tabs items={["with reader", "with node:fs"]}>
-	```ts twoslash tab="with reader"
-	import { TextFileReader } from '@llamaindex/readers/text'
-	import { CodeSplitter } from '@llamaindex/node-parser/code'
-	import Parser from "tree-sitter";
-	import TS from "tree-sitter-typescript";
-
-	const parser = new Parser();
-	parser.setLanguage(TS.typescript as Parser.Language);
-	const codeSplitter = new CodeSplitter({
-		getParser: () => parser,
-	});
-	const reader = new TextFileReader();
-	const documents = await reader.loadData('path/to/file.ts');
-
-	const parsedDocuments = codeSplitter(documents);
-	//			  ^?
-	```
-
-	```ts twoslash tab="with node:fs"
-	import fs from 'node:fs/promises';
-	import { CodeSplitter } from '@llamaindex/node-parser/code'
-	import Parser from "tree-sitter";
-	import TS from "tree-sitter-typescript";
-
-	const parser = new Parser();
-	parser.setLanguage(TS.typescript as Parser.Language);
-	const codeSplitter = new CodeSplitter({
-	  getParser: () => parser,
-	});
-
-	const parsedDocuments = codeSplitter.splitText(await fs.readFile('path/to/file.ts', 'utf-8'));
-	//			 ^?
-	```
-</Tabs>
-
-You might setup WASM files for `web-tree-sitter` and use it in the browser.
-
-```ts
-import Parser from 'web-tree-sitter';
-
-Parser.init({
-	locateFile(scriptName: string) {
-	return '/' + scriptName
-},
-}).then(async () => {
-	const parser = new Parser();
-	const Lang = await Parser.Language.load('/tree-sitter-typescript.wasm');
-	parser.setLanguage(Lang);
-	return new CodeSplitter({
-		getParser: () => parser,
-		maxChars: 100
-	});
-});
-```
-
-In this example, you should put `tree-sitter-typescript.wasm` to the `public` folder for Next.js.
-
-And also update the `next.config.js` to make `@llamaindex/env` work properly.
-
-```js
-const config = {
-	webpack: (config) => {
-		if (Array.isArray(config.target) && config.target.includes('web')) {
-			config.target = ["web", "es2020"];
-		}
-		return config;
-	}
-}
-
-export default config;
-```
-
-## API Reference
-
-- [SentenceSplitter](/docs/api/classes/SentenceSplitter)
-- [MarkdownNodeParser](/docs/api/classes/MarkdownNodeParser)
-- [CodeSplitter](/docs/api/classes/CodeSplitter)

docs/llamaindexTS/modules/data/meta.json

@@ -1,4 +0,0 @@
-{
-  "title": "Data",
-  "pages": ["index", "readers", "data_index", "ingestion_pipeline", "stores"]
-}

docs/llamaindexTS/modules/data/readers/discord.mdx

@@ -1,39 +0,0 @@
----
-title: 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.
-
-## Installation
-
-```package-install
-npm install @llamaindex/discord
-```
-
-## 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.
-
-<include cwd>../../examples/readers/discord/reader.ts</include>
-
-### 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](/docs/api/classes/DiscordReader)

docs/llamaindexTS/modules/data/readers/index.mdx

@@ -1,113 +0,0 @@
----
-title: Loading Data
-description: Loading data using Readers into Documents
----
-
-Before you can start indexing your documents, you need to load them into memory.
-A reader is a module that loads data from a file into a `Document` object.
-
-## Install @llamaindex/readers
-
-If you want to use the reader module, you need to install `@llamaindex/readers`
-
-```package-install
-npm i @llamaindex/readers
-```
-
-We offer readers for different file formats.
-
-```ts twoslash
-import { CSVReader } from '@llamaindex/readers/csv';
-import { DocxReader } from '@llamaindex/readers/docx';
-import { HTMLReader } from '@llamaindex/readers/html';
-import { ImageReader } from '@llamaindex/readers/image';
-import { JSONReader } from '@llamaindex/readers/json';
-import { MarkdownReader } from '@llamaindex/readers/markdown';
-import { ObsidianReader } from '@llamaindex/readers/obsidian';
-import { PDFReader } from '@llamaindex/readers/pdf';
-import { TextFileReader } from '@llamaindex/readers/text';
-```
-
-## SimpleDirectoryReader
-
-[Open in StackBlitz](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 and delegates the actual reading to the reader specified in the `fileExtToReader` map.
-
-<include cwd>../../examples/readers/src/simple-directory-reader.ts</include>
-
-Currently, the following readers are mapped to specific file types:
-
-- [TextFileReader](/docs/api/classes/TextFileReader): `.txt`
-- [PDFReader](/docs/api/classes/PDFReader): `.pdf`
-- [CSVReader](/docs/api/classes/CSVReader): `.csv`
-- [MarkdownReader](/docs/api/classes/MarkdownReader): `.md`
-- [DocxReader](/docs/api/classes/DocxReader): `.docx`
-- [HTMLReader](/docs/api/classes/HTMLReader): `.htm`, `.html`
-- [ImageReader](/docs/api/classes/ImageReader): `.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
-
-<include cwd>../../examples/readers/src/custom-simple-directory-reader.ts</include>
-
-## Tips when using in non-Node.js environments
-
-When using `@llamaindex/readers` in a non-Node.js environment (such as Vercel Edge, Cloudflare Workers, etc.)
-Some classes are not exported from top-level entry file.
-
-The reason is that some classes are only compatible with Node.js runtime, (e.g. `PDFReader`) which uses Node.js specific APIs (like `fs`, `child_process`, `crypto`).
-
-If you need any of those classes, you have to import them instead directly through their file path in the package.
-
-As the `PDFReader` is not working with the Edge runtime, here's how to use the `SimpleDirectoryReader` with the `LlamaParseReader` to load PDFs:
-
-```typescript
-import { SimpleDirectoryReader } from "@llamaindex/readers/directory";
-import { LlamaParseReader } from "@llamaindex/cloud";
-
-export const DATA_DIR = "./data";
-
-export async function getDocuments() {
-  const reader = new SimpleDirectoryReader();
-  // Load PDFs using LlamaParseReader
-  return await reader.loadData({
-    directoryPath: DATA_DIR,
-    fileExtToReader: {
-      pdf: new LlamaParseReader({ resultType: "markdown" }),
-    },
-  });
-}
-```
-
-> _Note_: Reader classes have to be added explicitly to the `fileExtToReader` map in the Edge version of the `SimpleDirectoryReader`.
-
-You'll find a complete example with LlamaIndexTS here: https://github.com/run-llama/create_llama_projects/tree/main/nextjs-edge-llamaparse
-
-
-## Load file natively using Node.js Customization Hooks
-
-We have a helper utility to allow you to import a file in Node.js script.
-
-```shell 
-node --import @llamaindex/readers/node ./script.js
-```
-
-```ts
-import csv from './path/to/data.csv';
-
-const text = csv.getText()
-```
-
-## API Reference
-
-- [SimpleDirectoryReader](/docs/api/classes/SimpleDirectoryReader)

docs/llamaindexTS/modules/data/readers/json.mdx

@@ -1,155 +0,0 @@
----
-title: 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)
-
-## Installation
-
-```package-install
-npm i llamaindex @llamaindex/readers
-```
-
-## Usage
-
-```ts
-import { JSONReader } from "@llamaindex/readers/json";
-
-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
-
-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": "こんにちは世界"
-```
-
-## API Reference
-
-- [JSONReader](/docs/api/classes/JSONReader)

docs/llamaindexTS/modules/data/readers/llama_parse/images.mdx

@@ -1,114 +0,0 @@
----
-title: 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.
-
-## Installation
-
-```package-install
-npm i llamaindex @llamaindex/cloud @llamaindex/openai
-```
-
-## Usage
-
-We use the `getImages` method to input our array of JSON objects, download the images to a specified folder and get a list of ImageNodes.
-
-```ts
-const reader = new LlamaParseReader();
-const jsonObjs = await reader.loadJson("../data/uber_10q_march_2022.pdf");
-const imageDicts = await reader.getImages(jsonObjs, "images");
-```
-
-### Multimodal Indexing
-
-You can create an index across both text and image nodes by requesting alternative text for the image from a multimodal LLM.
-
-```ts
-import { Document, ImageNode, VectorStoreIndex } from "llamaindex";
-import { LlamaParseReader } from "@llamaindex/cloud";
-import { OpenAI } from "@llamaindex/openai";
-import { createMessageContent } from "llamaindex";
-
-const reader = new LlamaParseReader();
-async function main() {
-  // Load PDF using LlamaParse JSON mode and return an array of json objects
-  const jsonObjs = await reader.loadJson("../data/uber_10q_march_2022.pdf");
-  // Access the first "pages" (=a single parsed file) object in the array
-  const jsonList = jsonObjs[0]["pages"];
-
-  const textDocs = getTextDocs(jsonList);
-  const imageTextDocs = await getImageTextDocs(jsonObjs);
-  const documents = [...textDocs, ...imageTextDocs];
-  // Split text, create embeddings and query the index
-  const index = await VectorStoreIndex.fromDocuments(documents);
-  const queryEngine = index.asQueryEngine();
-  const response = await queryEngine.query({
-    query:
-      "What does the bar graph titled 'Monthly Active Platform Consumers' show?",
-  });
-
-  console.log(response.toString());
-}
-
-main().catch(console.error);
-```
-
-We use two helper functions to create documents from the text and image nodes provided.
-
-#### Text Documents
-
-To create documents from the text nodes of the json object, we just map the needed values to a new `Document` object. In this case we assign the text as text and the page number as metadata.
-
-```ts
-function getTextDocs(jsonList: { text: string; page: number }[]): Document[] {
-  return jsonList.map(
-    (page) => new Document({ text: page.text, metadata: { page: page.page } }),
-  );
-}
-```
-
-#### Image Documents
-
-To create documents from the images, we need to use a multimodal LLM to generate alt text.
-
-For this we create `ImageNodes` and add them as part of our message.
-
-We can use the `createMessageContent` function to simplify this.
-
-```ts
-async function getImageTextDocs(
-  jsonObjs: Record<string, any>[],
-): Promise<Document[]> {
-  const llm = new OpenAI({
-    model: "gpt-4o",
-    temperature: 0.2,
-    maxTokens: 1000,
-  });
-  const imageDicts = await reader.getImages(jsonObjs, "images");
-  const imageDocs = [];
-
-  for (const imageDict of imageDicts) {
-    const imageDoc = new ImageNode({ image: imageDict.path });
-    const prompt = () => `Describe the image as alt text`;
-    const message = await createMessageContent(prompt, [imageDoc]);
-
-    const response = await llm.complete({
-      prompt: message,
-    });
-
-    const doc = new Document({
-      text: response.text,
-      metadata: { path: imageDict.path },
-    });
-    imageDocs.push(doc);
-  }
-
-  return imageDocs;
-}
-```
-
-The returned `imageDocs` have the alt text assigned as text and the image path as metadata.
-
-You can see the full example file [here](https://github.com/run-llama/LlamaIndexTS/blob/main/examples/readers/src/llamaparse-json.ts).
-

docs/llamaindexTS/modules/data/readers/llama_parse/index.mdx

@@ -1,63 +0,0 @@
----
-title: LlamaParse
----
-
-LlamaParse is an API created by LlamaIndex to efficiently parse files, e.g. it's great at converting PDF tables into markdown.
-
-To use it, first login and get an API key from https://cloud.llamaindex.ai. Make sure to store the key as `apiKey` parameter or in the environment variable `LLAMA_CLOUD_API_KEY`.
-
-Official documentation for LlamaParse can be found [here](https://docs.cloud.llamaindex.ai/).
-
-## Usage
-
-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:
-
-<include cwd>../../examples/readers/src/llamaparse.ts</include>
-
-### Params
-
-All options can be set with the `LlamaParseReader` constructor.
-
-They can be divided into two groups.
-
-#### General params:
-
-- `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 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` primarily helps with OCR recognition. Defaults to `en`.
-- `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 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
-
-Below a full example of `LlamaParse` integrated in `SimpleDirectoryReader` with additional options.
-
-<include cwd>../../examples/readers/src/simple-directory-reader-with-llamaparse.ts</include>
-
-## API Reference
-
-- [SimpleDirectoryReader](/docs/api/classes/SimpleDirectoryReader)