Release 0.11.5 (#1986)

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

CLAUDE.md

@@ -0,0 +1,92 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Development Commands
+
+This project uses pnpm as the package manager and Turbo for build orchestration:
+
+- `pnpm install` - Install all dependencies
+- `pnpm build` - Build all packages using Turbo
+- `pnpm dev` - Start development mode for all packages
+- `pnpm test` - Run all unit tests
+- `pnpm e2e` - Run end-to-end tests
+- `pnpm lint` - Run ESLint across all packages
+- `pnpm type-check` - Run TypeScript type checking across workspace
+- `pnpm format` - Check code formatting with Prettier
+- `pnpm format:write` - Auto-fix formatting issues
+- `pnpm circular-check` - Check for circular dependencies using madge
+
+For individual package development:
+
+- `turbo run build --filter="@llamaindex/core"` - Build specific package
+- `turbo run test --filter="@llamaindex/core"` - Test specific package
+- Navigate to specific package directory and run `pnpm test` for focused testing
+- `pnpm clean` - Remove all build artifacts and node_modules across workspace
+
+## Architecture Overview
+
+LlamaIndex.TS is a TypeScript data framework for LLM applications organized as a pnpm monorepo with multiple runtime environment support (Node.js, Deno, Bun, Vercel Edge, Cloudflare Workers).
+
+### Package Structure
+
+**Core Packages:**
+
+- `packages/core/` - Abstract base classes and interfaces for all runtime environments
+- `packages/llamaindex/` - Main package that aggregates core functionality
+- `packages/env/` - Environment-specific compatibility layers for different JS runtimes
+
+**Provider Packages (`packages/providers/`):**
+
+- LLM providers: `openai/`, `anthropic/`, `ollama/`, `google/`, `groq/`, etc.
+- Vector stores: `storage/pinecone/`, `storage/chroma/`, `storage/qdrant/`, etc.
+- Embeddings: Various embedding providers integrated within LLM packages
+- Readers: `assemblyai/`, `discord/`, `notion/` for data ingestion
+
+**Specialized Packages:**
+
+- `packages/cloud/` - LlamaCloud integration for managed services
+- `packages/tools/` - Function calling tools and utilities
+- `packages/workflow/` - Agent workflow orchestration
+- `packages/readers/` - File format readers (PDF, DOCX, etc.)
+
+### Key Architectural Patterns
+
+**Runtime Abstraction:** Core functionality is runtime-agnostic, with environment-specific implementations in separate entry points (`index.ts`, `index.edge.ts`, `index.workerd.ts`).
+
+**Provider Pattern:** LLMs, embeddings, and vector stores implement common interfaces from `@llamaindex/core`, allowing easy swapping between providers.
+
+**Modular Design:** Each provider is a separate package to minimize bundle size - users install only what they need.
+
+**Data Flow:** Document → NodeParser → Embedding → VectorStore → Retriever → QueryEngine → Response
+
+### Core Components
+
+- **Agents and Workflows:** Abstractions for building agentic workflows and agents in `packages/workflow`
+- **Chat Engines:** Conversational interfaces in `core/chat-engine/`
+- **Query Engines:** Document querying with retrieval in `core/query-engine/`
+- **Indices:** VectorStoreIndex, SummaryIndex, KeywordTable in `llamaindex/indices/`
+- **Node Parsers:** Text splitting and chunking in `core/node-parser/`
+- **Ingestion Pipeline:** Document processing workflows in `llamaindex/ingestion/`
+- **Storage:** Chat stores, document stores, index stores, and KV stores in `core/storage/`
+
+### Deprecated Components
+
+- **Agents:** ReAct and function calling agents in `core/agent/` and `llamaindex/agent/`
+
+### Testing Structure
+
+- Unit tests in each package's `tests/` directory
+- E2E tests in `e2e/` directory with runtime-specific examples
+- Tests depend on build artifacts, so always run `pnpm build` before testing
+
+### Multi-Runtime Support
+
+The codebase supports multiple JavaScript runtimes through conditional exports and separate entry points. When making changes, consider compatibility across Node.js, Deno, Bun, and edge runtimes.
+
+### Development Notes
+
+- The project uses Husky for git hooks with lint-staged for pre-commit formatting and linting
+- All packages use bunchee for building with dual CJS/ESM support
+- Core package exports are organized as sub-modules (e.g., `@llamaindex/core/llms`, `@llamaindex/core/embeddings`)
+- Always run `pnpm build` before running tests, as tests depend on build artifacts

apps/next/CHANGELOG.md

@@ -1,5 +1,32 @@
 # @llamaindex/doc
 
+## 0.2.24
+
+### Patch Changes
+
+- Updated dependencies [766054b]
+- Updated dependencies [71598f8]
+  - @llamaindex/workflow@1.1.6
+  - @llamaindex/core@0.6.9
+  - llamaindex@0.11.5
+  - @llamaindex/cloud@4.0.13
+  - @llamaindex/node-parser@2.0.9
+  - @llamaindex/openai@0.4.3
+  - @llamaindex/readers@3.1.7
+
+## 0.2.23
+
+### Patch Changes
+
+- Updated dependencies [c927457]
+  - @llamaindex/openai@0.4.2
+  - @llamaindex/core@0.6.8
+  - @llamaindex/cloud@4.0.12
+  - llamaindex@0.11.4
+  - @llamaindex/node-parser@2.0.8
+  - @llamaindex/readers@3.1.6
+  - @llamaindex/workflow@1.1.5
+
 ## 0.2.22
 
 ### Patch Changes

apps/next/CLAUDE.md

@@ -0,0 +1,143 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with the LlamaIndex.TS documentation site.
+
+## Application Overview
+
+This is a Next.js documentation site (`@llamaindex/doc`) that serves as the official documentation for LlamaIndex.TS. It's built using Fumadocs, a modern documentation framework, and includes interactive features, API documentation generation, and AI-powered chat functionality.
+
+## Development Commands
+
+From this directory (`apps/next/`):
+
+- `pnpm dev` - Start development server with Turbo
+- `pnpm build` - Build the documentation site (includes `prebuild` step)
+- `pnpm start` - Start production server
+- `pnpm build:docs` - Generate API documentation from TypeScript source
+- `pnpm validate-links` - Validate all internal and external links
+
+Key build process:
+
+1. `prebuild` runs `build:docs` to generate API documentation using TypeDoc
+2. `build` runs Next.js build process
+3. `postbuild` runs post-processing scripts and link validation
+
+## Architecture
+
+### Framework Stack
+
+- **Next.js 15.3** - React framework with App Router
+- **Fumadocs** - Documentation framework with MDX support
+- **React Server Components** - AI chat functionality with server actions
+- **Tailwind CSS** - Styling with custom design system
+- **TypeScript** - Full type safety
+
+### Key Dependencies
+
+- **Fumadocs ecosystem**: `fumadocs-ui`, `fumadocs-mdx`, `fumadocs-core`, `fumadocs-openapi`
+- **AI features**: `ai` package for React Server Components chat
+- **Code features**: Monaco Editor, Shiki syntax highlighting, Twoslash TypeScript integration
+- **UI components**: Radix UI primitives, Framer Motion animations
+- **Content processing**: MDX, remark/rehype plugins, TypeDoc for API generation
+
+### Directory Structure
+
+**Content Management:**
+
+- `src/content/docs/` - MDX documentation files organized by topic
+- `src/content/docs/api/` - Auto-generated API documentation from TypeScript
+- `scripts/` - Build-time documentation generation and validation
+
+**Application Code:**
+
+- `src/app/` - Next.js App Router pages and API routes
+- `src/components/` - Reusable React components including UI library
+- `src/lib/` - Utilities, constants, and configuration
+
+**Configuration:**
+
+- `source.config.ts` - Fumadocs MDX configuration with plugins
+- `next.config.mjs` - Next.js configuration with MDX integration
+- `tailwind.config.mjs` - Tailwind CSS customization
+
+### Key Features
+
+**Documentation Features:**
+
+- MDX-based content with TypeScript code highlighting
+- Auto-generated API documentation from TypeScript source
+- Interactive code examples with Monaco Editor
+- Math equation support with KaTeX
+- Link validation and build-time checks
+
+**Interactive Features:**
+
+- AI-powered chat interface using React Server Components
+- Code demos with live TypeScript execution
+- Interactive UI components and animations
+- Search functionality across all documentation
+
+**Build Process:**
+
+- TypeDoc generates API documentation from workspace packages
+- Custom scripts transform and validate generated content
+- Link checking ensures all internal/external links work
+- Static site generation with 10-minute timeout for large documentation set
+
+### Configuration Files
+
+**source.config.ts**: Defines MDX processing pipeline with:
+
+- Code highlighting themes (Catppuccin)
+- Twoslash TypeScript integration
+- Remark/rehype plugins for enhanced Markdown
+- Content directories including external docs
+
+**next.config.mjs**: Next.js configuration with:
+
+- Extended static generation timeout (10 minutes)
+- Monaco Editor transpilation
+- Server external packages for build optimization
+- Webpack/Turbopack aliases for browser compatibility
+
+### Content Organization
+
+**Documentation Structure:**
+
+- `/docs/llamaindex/` - Core LlamaIndex.TS documentation
+- `/docs/cloud/` - LlamaCloud integration guides
+- `/docs/api/` - Auto-generated TypeScript API reference
+
+**Content Sources:**
+
+- Local MDX files in `src/content/docs/`
+- External docs from `@llama-flow/docs` package
+- Generated API docs from TypeScript source
+
+### Development Notes
+
+- Documentation content is sourced from multiple locations including external packages
+- API documentation is regenerated on each build from TypeScript source
+- The site uses advanced MDX features including custom transformers and plugins
+- Build process includes comprehensive link validation
+- Large memory allocation needed for TypeDoc generation (`--max-old-space-size=8192`)
+- Chat functionality uses React Server Components with streaming responses
+
+### AI Chat Integration
+
+The documentation includes an AI chat feature that:
+
+- Uses React Server Components for server-side AI processing
+- Integrates with LlamaIndex.TS packages for demonstrations
+- Provides interactive examples and code generation
+- Streams responses for better user experience
+
+### Content Authoring
+
+When adding new documentation:
+
+- Create MDX files in appropriate `src/content/docs/` subdirectories
+- Follow existing content structure and frontmatter conventions
+- Use Fumadocs MDX features like code blocks, callouts, and tabs
+- API documentation is auto-generated - edit TypeScript source comments instead
+- Run `pnpm validate-links` to check all links before publishing

apps/next/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llamaindex/doc",
-  "version": "0.2.22",
+  "version": "0.2.24",
   "private": true,
   "scripts": {
     "postinstall": "fumadocs-mdx",
@@ -16,7 +16,7 @@
     "@huggingface/transformers": "^3.5.0",
     "@icons-pack/react-simple-icons": "^10.1.0",
     "@llama-flow/docs": "0.0.8",
-    "@llamaindex/chat-ui": "0.2.0",
+    "@llamaindex/chat-ui-docs": "0.0.3",
     "@llamaindex/cloud": "workspace:*",
     "@llamaindex/core": "workspace:*",
     "@llamaindex/node-parser": "workspace:*",

apps/next/scripts/validate-links.mts

@@ -13,7 +13,7 @@ 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"];
+const ALLOWED_LINKS = ["/docs/llamaflow", "/docs/chat-ui"];
 
 interface LinkValidationResult {
   file: string;

apps/next/source.config.ts

@@ -9,7 +9,11 @@ import rehypeKatex from "rehype-katex";
 import remarkMath from "remark-math";
 
 export const docs = defineDocs({
-  dir: ["./src/content/docs", "./node_modules/@llama-flow/docs"],
+  dir: [
+    "./src/content/docs",
+    "./node_modules/@llama-flow/docs",
+    "./node_modules/@llamaindex/chat-ui-docs",
+  ],
   docs: {
     async: true,
   },

apps/next/src/app/docs/[[...slug]]/page.tsx

@@ -1,4 +1,3 @@
-import { ChatDemoRSC } from "@/components/demo/chat/rsc/demo";
 import * as demos from "@/components/demo/lazy";
 import { createMetadata, metadataImage } from "@/lib/metadata";
 import { openapi, source } from "@/lib/source";
@@ -51,7 +50,6 @@ export default async function Page(props: {
             ...Icons,
             ...defaultMdxComponents,
             ...demos,
-            ChatDemoRSC,
             Accordion,
             Accordions,
             APIPage: (props) => <APIPage {...openapi.getAPIPageProps(props)} />,

apps/next/src/components/demo/chat/api/demo.tsx

@@ -1,21 +0,0 @@
-"use client";
-import {
-  ChatHandler,
-  ChatInput,
-  ChatMessages,
-  ChatSection,
-} from "@llamaindex/chat-ui";
-import { useChat } from "ai/react";
-
-export const ChatDemo = () => {
-  const handler = useChat();
-  return (
-    <ChatSection handler={handler as ChatHandler}>
-      <ChatMessages>
-        <ChatMessages.List className="h-auto max-h-[400px]" />
-        <ChatMessages.Actions />
-      </ChatMessages>
-      <ChatInput />
-    </ChatSection>
-  );
-};

apps/next/src/components/demo/chat/rsc/ai-action.tsx

@@ -1,57 +0,0 @@
-import { Markdown } from "@llamaindex/chat-ui/widgets";
-import { MockLLM } from "@llamaindex/core/utils";
-import { generateId, Message } from "ai";
-import { createAI, createStreamableUI, getMutableAIState } from "ai/rsc";
-import { type ChatMessage, Settings, SimpleChatEngine } from "llamaindex";
-import { ReactNode } from "react";
-
-type ServerState = Message[];
-type FrontendState = Array<Message & { display: ReactNode }>;
-type Actions = {
-  chat: (message: Message) => Promise<Message & { display: ReactNode }>;
-};
-
-Settings.llm = new MockLLM(); // config your LLM here
-
-export const AI = createAI<ServerState, FrontendState, Actions>({
-  initialAIState: [],
-  initialUIState: [],
-  actions: {
-    chat: async (message: Message) => {
-      "use server";
-
-      const aiState = getMutableAIState<typeof AI>();
-      aiState.update((prev) => [...prev, message]);
-
-      const uiStream = createStreamableUI();
-      const chatEngine = new SimpleChatEngine();
-      const assistantMessage: Message = {
-        id: generateId(),
-        role: "assistant",
-        content: "",
-      };
-
-      // run the async function without blocking
-      (async () => {
-        const chatResponse = await chatEngine.chat({
-          stream: true,
-          message: message.content,
-          chatHistory: aiState.get() as ChatMessage[],
-        });
-
-        for await (const chunk of chatResponse) {
-          assistantMessage.content += chunk.delta;
-          uiStream.update(<Markdown content={assistantMessage.content} />);
-        }
-
-        aiState.done([...aiState.get(), assistantMessage]);
-        uiStream.done();
-      })();
-
-      return {
-        ...assistantMessage,
-        display: uiStream.value,
-      };
-    },
-  },
-});

apps/next/src/components/demo/chat/rsc/chat-section.tsx

@@ -1,35 +0,0 @@
-"use client";
-
-import {
-  ChatHandler,
-  ChatInput,
-  ChatMessage,
-  ChatMessages,
-  ChatSection as ChatSectionUI,
-  Message,
-} from "@llamaindex/chat-ui";
-import { useChatRSC } from "./use-chat-rsc";
-
-export const ChatSectionRSC = () => {
-  const handler = useChatRSC();
-  return (
-    <ChatSectionUI handler={handler as ChatHandler}>
-      <ChatMessages>
-        <ChatMessages.List className="h-auto max-h-[400px]">
-          {handler.messages.map((message, index) => (
-            <ChatMessage
-              key={index}
-              message={message as Message}
-              isLast={index === handler.messages.length - 1}
-            >
-              <ChatMessage.Avatar />
-              <ChatMessage.Content>{message.display}</ChatMessage.Content>
-            </ChatMessage>
-          ))}
-          <ChatMessages.Loading />
-        </ChatMessages.List>
-      </ChatMessages>
-      <ChatInput />
-    </ChatSectionUI>
-  );
-};

apps/next/src/components/demo/chat/rsc/demo.tsx

@@ -1,8 +0,0 @@
-import { AI } from "./ai-action";
-import { ChatSectionRSC } from "./chat-section";
-
-export const ChatDemoRSC = () => (
-  <AI>
-    <ChatSectionRSC />
-  </AI>
-);

apps/next/src/components/demo/chat/rsc/use-chat-rsc.tsx

@@ -1,41 +0,0 @@
-"use client";
-
-import { useActions } from "ai/rsc";
-
-import { generateId, Message } from "ai";
-import { useUIState } from "ai/rsc";
-import { useState } from "react";
-import { AI } from "./ai-action";
-
-export function useChatRSC() {
-  const [input, setInput] = useState<string>("");
-  const [isLoading, setIsLoading] = useState<boolean>(false);
-  const [messages, setMessages] = useUIState<typeof AI>();
-  const { chat } = useActions<typeof AI>();
-
-  const append = async (message: Omit<Message, "id">) => {
-    const newMsg: Message = { ...message, id: generateId() };
-
-    setIsLoading(true);
-    try {
-      setMessages((prev) => [...prev, { ...newMsg, display: message.content }]);
-      const assistantMsg = await chat(newMsg);
-      setMessages((prev) => [...prev, assistantMsg]);
-    } catch (error) {
-      console.error(error);
-    }
-    setIsLoading(false);
-    setInput("");
-
-    return message.content;
-  };
-
-  return {
-    input,
-    setInput,
-    isLoading,
-    messages,
-    setMessages,
-    append,
-  };
-}

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

@@ -1,11 +1,6 @@
 "use client";
 import dynamic from "next/dynamic";
 
-// lazy load client components
-export const ChatDemo = dynamic(() =>
-  import("@/components/demo/chat/api/demo").then((mod) => mod.ChatDemo),
-);
-
 export const CodeNodeParserDemo = dynamic(() =>
   import("@/components/demo/code-node-parser").then(
     (mod) => mod.CodeNodeParserDemo,

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

@@ -33,7 +33,7 @@ const jokeAgent = agent({
 
 // Run the workflow
 const result = await jokeAgent.run("Tell me something funny");
-console.log(result); // Baby Llama is called cria
+console.log(result.data.result); // Baby Llama is called cria
 ```
 
 ### Event Streaming
@@ -44,7 +44,7 @@ Agent Workflows provide a unified interface for event streaming, making it easy
 import { agentToolCallEvent, agentStreamEvent } from "@llamaindex/workflow";
 
 // Get the workflow execution context
-const events = workflow.runStream("Tell me something funny");
+const events = jokeAgent.runStream("Tell me something funny");
 
 // Stream and handle events
 for await (const event of events) {
@@ -112,6 +112,7 @@ const agents = multiAgent({
 const result = await agents.run(
   "Give me a morning greeting with a joke and the weather in San Francisco"
 );
+console.log(result.data.result);
 ```
 
 The workflow will coordinate between agents, allowing them to handle different aspects of the request and hand off tasks when appropriate.

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

@@ -42,6 +42,7 @@ similarity float
 )
 language plpgsql
 as $$
+#variable_conflict use_column
 begin
 return query
 select

apps/next/src/content/docs/llamaindex/modules/ui/chat.mdx

@@ -1,44 +0,0 @@
----
-title: Using API Route
-description: Chat interface for your LlamaIndexTS application using API Route
----
-
-Using [chat-ui](https://github.com/run-llama/chat-ui), it's easy to add a chat interface to your LlamaIndexTS application.
-You just need to create an API route that provides an `api/chat` endpoint and a chat component to consume the API.
-
-## API route
-
-As an example, this is an API route for the Next.js App Router. Copy the following code into your `app/api/chat/route.ts` file to get started:
-
-```json doc-gen:file
-{
-  "file": "./src/app/api/chat/route.ts",
-	"codeblock": true
-}
-```
-
-## Chat UI
-
-This is the simplest way to add a chat interface to your application. Copy the following code into your application to consume the API:
-
-```json doc-gen:file
-{
-  "file": "./src/components/demo/chat/api/demo.tsx",
-	"codeblock": true
-}
-```
-
-## Try it out ⬇️
-
-Combining both, you're getting a fully functional chat interface:
-
-<ChatDemo />
-
-
-## Next Steps
-
-The steps above are the bare minimum to get a chat interface working. From here, you can go two ways:
-
-1. Use [create-llama](https://github.com/run-llama/create-llama) to scaffold a new LlamaIndexTS project including complex API routes and chat interfaces or
-2. Learn more about [chat-ui](https://github.com/run-llama/chat-ui) and [LlamaIndexTS](https://github.com/run-llama/llamaindex-ts) to customize the chat interface and API routes to your needs.
-

apps/next/src/content/docs/llamaindex/modules/ui/index.mdx

@@ -0,0 +1,8 @@
+---
+title: Using @llamaindex/chat-ui
+description: Chat UI components for your LlamaIndexTS application
+---
+
+@llamaindex/chat-ui is a library that provides a set of components for building chat user interfaces. It is built on top of [Shadcn UI](https://ui.shadcn.com).
+
+Check out our [chat-ui](/docs/chat-ui) documentation or try running examples on the [ui.llamaindex.ai](https://ui.llamaindex.ai) website.

apps/next/src/content/docs/llamaindex/modules/ui/install.mdx

@@ -1,22 +0,0 @@
----
-title: Install @llamaindex/chat
-description: Chat interface for your LlamaIndexTS application
----
-
-## Quick Start
-
-You can quickly add a chatbot to your project by using Shadcn CLI command:
-
-```sh
-npx shadcn@latest add https://ui.llamaindex.ai/r/chat.json
-```
-
-## Manual Installation
-
-To install the package, run the following command in your project directory:
-
-```sh
-npm i @llamaindex/chat-ui
-```
-
-For more information, check out the [github.comrun-llama/chat-ui](https://github.com/run-llama/chat-ui)

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

@@ -9,161 +9,11 @@ LlamaIndexServer is a Next.js-based application that allows you to quickly launc
 
 ## Features
 
-- Serving a workflow as a chatbot
+- Add a sophisticated chatbot UI to your LlamaIndex workflow
+- Edit code and document artifacts in an OpenAI Canvas-style UI
+- Extendable UI components for events and headers
 - Built on Next.js for high performance and easy API development
-- Optional built-in chat UI with extendable UI components
-- Prebuilt development code
-
-## Installation
-
-```package-install
-npm i @llamaindex/server
-```
 
 ## Quick Start
 
-Create an `index.ts` file and add the following code:
-
-```ts
-import { LlamaIndexServer } from "@llamaindex/server";
-import { wiki } from "@llamaindex/tools"; // or any other tool
-
-const createWorkflow = () => agent({ tools: [wiki()] })
-
-new LlamaIndexServer({
-  workflow: createWorkflow,
-  uiConfig: {
-    appTitle: "LlamaIndex App",
-    starterQuestions: ["Who is the first president of the United States?"],
-  },
-}).start();
-```
-
-## Running the Server
-
-In the same directory as `index.ts`, run the following command to start the server:
-
-```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?"}'
-```
-
-## Configuration Options
-
-The `LlamaIndexServer` accepts the following configuration options:
-
-- `workflow`: A callable function that creates a workflow instance for each request
-- `uiConfig`: An object to configure the chat UI containing the following properties:
-  - `appTitle`: The title of the application (default: `"LlamaIndex App"`)
-  - `starterQuestions`: List of starter questions for the chat UI (default: `[]`)
-  - `componentsDir`: The directory for custom UI components rendering events emitted by the workflow. The default is undefined, which does not render custom UI components.
-  - `llamaCloudIndexSelector`: Whether to show the LlamaCloud index selector in the chat UI (requires `LLAMA_CLOUD_API_KEY` to be set in the environment variables) (default: `false`)
-
-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
-
-The server includes a default chat endpoint at `/api/chat` for handling chat interactions.
-
-### Chat UI
-
-The server always provides a chat interface at the root path (`/`) with:
-
-- Configurable starter questions
-- Real-time chat interface
-- API endpoint integration
-
-### 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.
-
-
-## 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.
-
-## 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)
+Check the latest information on the NPM package page: https://www.npmjs.com/package/@llamaindex/server

apps/next/src/content/docs/llamaindex/modules/ui/meta.json

@@ -2,5 +2,5 @@
   "title": "Chat UI",
   "description": "Use chat-ui to add a chat interface to your LlamaIndexTS application.",
   "defaultOpen": false,
-  "pages": ["install", "chat", "rsc", "llamaindex-server"]
+  "pages": ["index", "llamaindex-server"]
 }

apps/next/src/content/docs/llamaindex/modules/ui/rsc.mdx

@@ -1,65 +0,0 @@
----
-title: Using Next.js RSC
-description: Chat interface for your LlamaIndexTS application using Next.js RSC
----
-
-Using [chat-ui](https://github.com/run-llama/chat-ui), it's easy to add a chat interface to your LlamaIndexTS application using [Next.js RSC](https://nextjs.org/docs/app/building-your-application/rendering/server-components) and [Vercel AI RSC](https://sdk.vercel.ai/docs/ai-sdk-rsc/overview).
-
-With RSC, the chat messages are not returned as JSON from the server (like when using an [API route](/docs/llamaindex/modules/ui/chat)), instead the chat message components are rendered on the server side.
-This is for example useful for rendering a whole chat history on the server before sending it to the client. [Check here](https://sdk.vercel.ai/docs/getting-started/navigating-the-library#when-to-use-ai-sdk-rsc), for a discussion of when to use use RSC.
-
-For implementing a chat interface with RSC, you need to create an AI action and then connect the chat interface to use it.
-
-## Create an AI action
-
-First, define an [AI context provider](https://sdk.vercel.ai/examples/rsc/state-management/ai-ui-states) with a chat server action:
-
-```json doc-gen:file
-{
-  "file": "./src/components/demo/chat/rsc/ai-action.tsx",
-	"codeblock": true
-}
-```
-
-The chat server action is using LlamaIndexTS to generate a response based on the chat history and the user input.
-
-## Create the chat UI
-
-The entrypoint of our application initializes the AI provider for the application and adds a `ChatSection` component:
-
-```json doc-gen:file
-{
-  "file": "./src/components/demo/chat/rsc/demo.tsx",
-	"codeblock": true
-}
-```
-
-The `ChatSection` component is created by using chat components from @llamaindex/chat-ui:
-
-```json doc-gen:file
-{
-  "file": "./src/components/demo/chat/rsc/chat-section.tsx",
-	"codeblock": true
-}
-```
-
-It is using a `useChatRSC` hook to conntect the chat interface to the `chat` AI action that we defined earlier:
-
-```json doc-gen:file
-{
-  "file": "./src/components/demo/chat/rsc/use-chat-rsc.tsx",
-	"codeblock": true
-}
-```
-
-## Try RSC Chat ⬇️
-
-<ChatDemoRSC />
-
-## Next Steps
-
-The steps above are the bare minimum to get a chat interface working with RSC. From here, you can go two ways:
-
-1. Use our [full-stack RSC example](https://github.com/run-llama/nextjs-rsc) based on [create-llama](https://github.com/run-llama/create-llama) to get started quickly with a fully working chat interface or
-2. Learn more about [AI RSC](https://sdk.vercel.ai/examples/rsc), [chat-ui](https://github.com/run-llama/chat-ui) and [LlamaIndexTS](https://github.com/run-llama/llamaindex-ts) to customize the chat interface and AI actions to your needs.
-

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

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

apps/next/turbo.json

@@ -5,6 +5,7 @@
     "build": {
       "inputs": [
         "node_modules/@llama-flow/docs/**",
+        "node_modules/@llamaindex/chat-ui-docs/**",
         "src/**/*.ts",
         "src/**/*.tsx",
         "src/**/*.mdx",

e2e/CLAUDE.md

@@ -0,0 +1,135 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with the LlamaIndexTS e2e testing package.
+
+## Package Overview
+
+The `@llamaindex/e2e` package contains end-to-end tests and examples for LlamaIndexTS, ensuring the library works correctly across different runtime environments and use cases. It validates integration between core packages, providers, and real-world usage scenarios.
+
+## Development Commands
+
+Run e2e tests from the root directory using:
+
+- `pnpm e2e` - Run all e2e tests with mocked LLM responses
+- `pnpm e2e:nomock` - Run e2e tests with real API calls (requires API keys)
+
+Local e2e package commands:
+
+- `npm run e2e` - Run all e2e tests with mock register
+- `npm run e2e:nomock` - Run tests without mocking (real API calls)
+- `npm run e2e:updatesnap` - Update test snapshots
+
+## Testing Structure
+
+### Core Test Files (`node/`)
+
+**Main Test Suites:**
+
+- `smoke.e2e.ts` - CJS/ESM dual module compatibility tests and basic import validation
+- `openai.e2e.ts` - OpenAI provider integration tests (LLM, agents, tools)
+- `claude.e2e.ts` - Anthropic Claude provider tests
+- `ollama.e2e.ts` - Ollama local LLM provider tests
+- `react.e2e.ts` - ReAct agent framework tests
+- `issue.e2e.ts` - Regression tests for specific GitHub issues
+
+**Specialized Tests:**
+
+- `embedding/clip.e2e.ts` - CLIP embedding model tests
+- `vector-store/` - Vector database integration tests (Pinecone, PostgreSQL with pgvector)
+
+### Test Utilities
+
+- `utils.ts` - Common test utilities and helper functions
+- `fixtures/` - Test data and mock tool definitions
+- `snapshot/` - Stored test snapshots for regression testing
+- `mock-register.js` & `mock-module.js` - LLM response mocking system
+
+### Examples Directory (`examples/`)
+
+Runtime-specific example applications that serve as integration tests:
+
+**Edge/Serverless Runtimes:**
+
+- `cloudflare-worker-agent/` - Cloudflare Workers agent example with Vitest
+- `cloudflare-hono/` - Cloudflare Workers with Hono framework
+- `nextjs-edge-runtime/` - Next.js Edge Runtime compatibility
+- `nextjs-node-runtime/` - Next.js Node.js runtime example
+- `nextjs-agent/` - Next.js with agent integration
+
+**Client-Side:**
+
+- `llama-parse-browser/` - Browser-based LlamaParse integration
+- `vite-import-llamaindex/` - Vite bundler compatibility test
+
+**Alternative Frameworks:**
+
+- `waku-query-engine/` - Waku framework with query engine integration
+
+## Testing Patterns
+
+### Mock System
+
+The e2e tests use a sophisticated mocking system for consistent testing:
+
+- **Mock Register**: `mock-register.js` enables LLM response mocking
+- **Snapshot Testing**: Pre-recorded responses stored in `snapshot/` directory
+- **Real API Mode**: Tests can run against real APIs when `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, etc. are provided
+
+### Test Categories
+
+1. **Smoke Tests**: Basic import/export validation and dual module (CJS/ESM) compatibility
+2. **Provider Integration**: LLM provider functionality (chat, streaming, function calling)
+3. **Agent Tests**: Agent framework validation with tool calling and reasoning
+4. **Runtime Compatibility**: Cross-platform runtime environment testing
+5. **Regression Tests**: Issue-specific tests preventing regressions
+
+### Environment Conditions
+
+Tests validate multiple JavaScript runtime conditions:
+
+- `edge-light` - Vercel Edge Runtime
+- `workerd` - Cloudflare Workers runtime
+- `react-server` - React Server Components environment
+
+## Dependencies
+
+The package includes comprehensive workspace dependencies for testing all major LlamaIndexTS features:
+
+**Core Dependencies:**
+
+- `@llamaindex/core` - Base abstractions
+- `@llamaindex/env` - Runtime environment compatibility
+- `llamaindex` - Main package
+
+**Provider Dependencies:**
+
+- `@llamaindex/openai` - OpenAI integration
+- `@llamaindex/anthropic` - Anthropic Claude integration
+- `@llamaindex/ollama` - Ollama local LLM support
+- `@llamaindex/clip` - CLIP embedding models
+- `@llamaindex/pinecone` - Pinecone vector store
+- `@llamaindex/postgres` - PostgreSQL with pgvector
+
+**Testing Utilities:**
+
+- `@faker-js/faker` - Test data generation
+- `@huggingface/transformers` - Local model support
+- `consola` - Logging in tests
+- `dotenv` - Environment variable management
+- `tsx` - TypeScript execution for Node.js
+
+## Development Notes
+
+- **Build Dependency**: E2E tests depend on build artifacts, so always run `pnpm build` before testing
+- **API Keys**: Real API testing requires environment variables (`OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, etc.)
+- **Snapshot Updates**: Use `npm run e2e:updatesnap` to update test snapshots after intentional changes
+- **Mock vs Real**: Use mock mode for CI/fast development, real mode for integration validation
+- **Runtime Testing**: Examples serve dual purpose as integration tests and usage documentation
+- **Node.js Test Runner**: Uses built-in Node.js test runner with tsx for TypeScript support
+
+## Common Workflows
+
+1. **Adding New Provider**: Create test file in `node/`, add mock snapshots, validate across runtimes
+2. **Runtime Compatibility**: Add example in `examples/` with framework-specific testing setup
+3. **Regression Testing**: Add specific test case in `issue.e2e.ts` with GitHub issue reference
+4. **Mock Updates**: Update snapshots when LLM provider responses change intentionally

e2e/examples/cloudflare-hono/CLAUDE.md

@@ -0,0 +1,156 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with the LlamaIndexTS Cloudflare Workers + Hono example.
+
+## Package Overview
+
+The `@llamaindex/cloudflare-hono` package is an end-to-end example demonstrating how to use LlamaIndexTS in a Cloudflare Workers environment with the Hono web framework. This example showcases building an AI agent with vector search capabilities that runs on Cloudflare's edge runtime.
+
+## Development Commands
+
+- `npm run dev` or `npm start` - Start local development server with Wrangler
+- `npm run build` - Build for deployment (dry run to dist directory)
+- `npm run deploy` - Deploy to Cloudflare Workers
+- `npm run cf-typegen` - Generate TypeScript types for Cloudflare Workers
+
+## Architecture
+
+This example demonstrates a complete RAG (Retrieval-Augmented Generation) system running on Cloudflare Workers:
+
+### Key Components
+
+1. **Hono Framework**: Lightweight web framework optimized for edge runtimes
+2. **OpenAI Integration**: GPT-4o-mini for language model and text-embedding-3-small for embeddings
+3. **Pinecone Vector Store**: Cloud vector database for document storage and retrieval
+4. **OpenAI Agent**: Function-calling agent with tool integration
+5. **Query Engine Tool**: Business information retrieval tool
+
+### Request Flow
+
+1. POST request to `/llm` endpoint with `{ message: "user question" }`
+2. Environment setup using `@llamaindex/env` for Cloudflare Workers compatibility
+3. Dynamic imports for tree-shaking and edge runtime optimization
+4. LLM and embedding model configuration with API keys from environment
+5. Vector store connection to Pinecone with predefined namespace
+6. Vector index creation and retriever setup (top-k=3 similarity search)
+7. Query engine tool creation for business information retrieval
+8. OpenAI agent initialization with tools
+9. Agent chat execution and response extraction
+
+### Runtime Optimizations
+
+- **Dynamic Imports**: All LlamaIndex packages imported asynchronously for optimal cold start performance
+- **Environment Setup**: Uses `@llamaindex/env` package for Cloudflare Workers compatibility
+- **Tree Shaking**: Selective imports reduce bundle size for edge deployment
+- **Async Operations**: Fully async pipeline optimized for serverless execution
+
+## Configuration
+
+### Wrangler Configuration (`wrangler.toml`)
+
+- **Runtime**: Cloudflare Workers with Node.js AsyncLocalStorage compatibility
+- **Compatibility Date**: 2024-11-12 with `nodejs_als` flag
+- **Observability**: Enabled for monitoring and debugging
+- **Entry Point**: `src/index.ts`
+
+### TypeScript Configuration
+
+- **Target**: ES2021 for modern JavaScript features
+- **Module**: ES2022 with bundler module resolution
+- **Types**: Cloudflare Workers types for runtime compatibility
+- **Strict Mode**: Enabled for type safety
+
+### Environment Variables
+
+Required Cloudflare Workers environment variables:
+
+- `OPENAI_API_KEY` - OpenAI API access for LLM and embeddings
+- `PINECONE_API_KEY` - Pinecone vector database access
+
+## Dependencies
+
+### Runtime Dependencies
+
+- `hono` - Lightweight web framework for edge runtimes
+
+### Development Dependencies
+
+- `@cloudflare/workers-types` - TypeScript definitions for Cloudflare Workers
+- `wrangler` - Cloudflare Workers CLI and development server
+- `typescript` - TypeScript compiler
+
+### LlamaIndexTS Integration
+
+This example relies on workspace dependencies:
+
+- `llamaindex` - Core LlamaIndexTS functionality
+- `@llamaindex/openai` - OpenAI provider (LLM, embeddings, agents)
+- `@llamaindex/pinecone` - Pinecone vector store integration
+- `@llamaindex/env` - Runtime environment compatibility layer
+
+## Code Patterns
+
+### Environment Setup Pattern
+
+```typescript
+const { setEnvs } = await import("@llamaindex/env");
+setEnvs(c.env);
+```
+
+Required first step for Cloudflare Workers compatibility.
+
+### Dynamic Import Pattern
+
+```typescript
+const { VectorStoreIndex, Settings } = await import("llamaindex");
+const { OpenAI, OpenAIAgent } = await import("@llamaindex/openai");
+```
+
+Optimizes bundle size and cold start performance.
+
+### Settings Configuration
+
+```typescript
+Settings.llm = new OpenAI({ model: "gpt-4o-mini" });
+Settings.embedModel = new OpenAIEmbedding({ model: "text-embedding-3-small" });
+Settings.nodeParser = new SentenceSplitter({ chunkSize: 8191 });
+```
+
+Global configuration for consistent LLM behavior.
+
+### Agent Tool Integration
+
+```typescript
+const tools = [
+  new QueryEngineTool({ queryEngine, metadata: { name, description } }),
+];
+const agent = new OpenAIAgent({ tools });
+```
+
+Function-calling agent with domain-specific tools.
+
+## Usage
+
+1. **Local Development**: Run `npm run dev` to start Wrangler development server
+2. **Environment Setup**: Configure `OPENAI_API_KEY` and `PINECONE_API_KEY` in Wrangler
+3. **API Testing**: POST to `/llm` with JSON payload `{ message: "your question" }`
+4. **Deployment**: Run `npm run deploy` to publish to Cloudflare Workers
+
+## Integration Testing
+
+This example serves as an integration test for:
+
+- Cloudflare Workers runtime compatibility
+- Hono framework integration
+- OpenAI provider functionality
+- Pinecone vector store operations
+- Agent workflow execution
+- Dynamic import optimization
+- Environment variable handling
+
+## Performance Considerations
+
+- **Cold Start**: Dynamic imports minimize initial bundle size
+- **Memory Usage**: Efficient vector operations with Pinecone cloud storage
+- **Latency**: Edge deployment reduces geographic latency
+- **Concurrency**: Serverless architecture handles concurrent requests efficiently

e2e/examples/cloudflare-worker-agent/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @llamaindex/cloudflare-worker-agent-test
 
+## 0.0.166
+
+### Patch Changes
+
+- llamaindex@0.11.5
+
+## 0.0.165
+
+### Patch Changes
+
+- llamaindex@0.11.4
+
 ## 0.0.164
 
 ### Patch Changes

e2e/examples/cloudflare-worker-agent/CLAUDE.md

@@ -0,0 +1,127 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with the Cloudflare Worker Agent example in the LlamaIndexTS e2e testing suite.
+
+## Package Overview
+
+The `@llamaindex/cloudflare-worker-agent-test` package demonstrates how to use LlamaIndex.TS within a Cloudflare Worker environment. This example serves as both a functional integration test and a reference implementation for deploying AI agents on Cloudflare's edge platform.
+
+## Development Commands
+
+Local development and testing:
+
+- `npm run dev` or `npm start` - Start Wrangler development server
+- `npm run build` - Build worker for deployment (dry-run with output to dist/)
+- `npm run deploy` - Deploy worker to Cloudflare
+- `npm run test` - Run Vitest tests using Cloudflare Workers test environment
+- `npm run cf-typegen` - Generate TypeScript types from wrangler.toml bindings
+
+## Architecture
+
+### Worker Implementation (`src/index.ts`)
+
+The worker implements a basic HTTP handler that:
+
+1. **Environment Setup**: Uses `@llamaindex/env` to configure runtime environment variables
+2. **Agent Initialization**: Creates an OpenAI agent with streaming support
+3. **Request Processing**: Accepts text input via HTTP request body
+4. **Streaming Response**: Returns streaming AI responses (though currently returns static "Hello, world!")
+
+**Key Components:**
+
+- Environment interface with `OPENAI_API_KEY` requirement
+- Dynamic imports for optimal bundle size (`@llamaindex/env`, `@llamaindex/openai`)
+- OpenAI agent with streaming chat capability
+- Transform stream for encoding chat response deltas
+
+### Configuration Files
+
+**Wrangler Configuration (`wrangler.toml`):**
+
+- Worker name: "agent"
+- Entry point: `src/index.ts`
+- Compatibility date: 2024-04-23
+- Node.js compatibility enabled via `nodejs_compat` flag
+- Commented examples for all major Cloudflare Worker bindings (D1, KV, R2, etc.)
+
+**TypeScript Configuration (`tsconfig.json`):**
+
+- Target: ES2021 with ES2022 modules
+- Bundler module resolution for Cloudflare Workers
+- Cloudflare Workers types included (`@cloudflare/workers-types/2023-07-01`)
+- Isolated modules enabled for edge runtime compatibility
+
+### Testing Setup
+
+**Vitest Configuration (`vitest.config.ts`):**
+
+- Uses `@cloudflare/vitest-pool-workers` for Cloudflare Workers testing environment
+- Integrates with wrangler.toml configuration
+- Enables testing in actual Workers runtime conditions
+
+**Test Implementation (`test/index.spec.ts`):**
+
+- Unit-style testing with Cloudflare Workers test utilities
+- Mock environment variables (OPENAI_API_KEY)
+- Uses `createExecutionContext()` and `waitOnExecutionContext()` for proper async testing
+- Currently marked as failing due to implementation bug (returns "Hello World!" instead of actual agent response)
+
+## Runtime Environment
+
+### Cloudflare Workers Compatibility
+
+This example demonstrates LlamaIndex.TS compatibility with the Cloudflare Workers runtime (`workerd`):
+
+- **Edge Runtime**: Runs on Cloudflare's global edge network
+- **Node.js Compatibility**: Uses `nodejs_compat` flag for Node.js APIs
+- **Module System**: ESM-only with dynamic imports for code splitting
+- **Environment Variables**: Secure handling via Cloudflare Workers environment bindings
+
+### Key Dependencies
+
+- `llamaindex` (workspace) - Main LlamaIndex.TS package
+- `@cloudflare/workers-types` - TypeScript definitions for Workers APIs
+- `@cloudflare/vitest-pool-workers` - Testing framework for Workers environment
+- `wrangler` - Cloudflare Workers CLI and build tool
+
+## Development Notes
+
+### Environment Variables
+
+- Create `.dev.vars` file with `OPENAI_API_KEY=your_key_here` for local development
+- Production secrets managed via `wrangler secret put OPENAI_API_KEY`
+
+### Known Issues
+
+- **Response Bug**: Worker currently returns static "Hello, world!" instead of streaming agent response (line 34 in `src/index.ts`)
+- **Test Status**: Main test marked as `.fails()` due to above implementation issue
+
+### Bundle Optimization
+
+- Uses dynamic imports to enable code splitting and reduce initial bundle size
+- Critical for Cloudflare Workers size limits and cold start performance
+- Environment setup (`@llamaindex/env`) imported dynamically to defer execution
+
+### Security Considerations
+
+- API keys handled through Cloudflare Workers environment bindings
+- No sensitive data stored in source code
+- Secure environment variable access pattern using `env` parameter
+
+## Common Workflows
+
+1. **Local Development**: Use `npm run dev` with `.dev.vars` file for API keys
+2. **Testing**: Run `npm test` to validate Workers runtime compatibility
+3. **Deployment**: Use `npm run deploy` after configuring production secrets
+4. **Debugging**: Use `wrangler tail` to view production logs and errors
+5. **Type Generation**: Run `npm run cf-typegen` after modifying wrangler.toml bindings
+
+## Integration Testing Purpose
+
+This example serves multiple purposes in the e2e test suite:
+
+- **Runtime Validation**: Ensures LlamaIndex.TS works in Cloudflare Workers environment
+- **Bundle Testing**: Validates that dynamic imports and code splitting work correctly
+- **API Integration**: Tests OpenAI provider integration in edge runtime
+- **Streaming Support**: Demonstrates streaming response handling in Workers
+- **Reference Implementation**: Provides template for real-world Cloudflare Workers deployments

e2e/examples/cloudflare-worker-agent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llamaindex/cloudflare-worker-agent-test",
-  "version": "0.0.164",
+  "version": "0.0.166",
   "type": "module",
   "private": true,
   "scripts": {

e2e/examples/llama-parse-browser/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @llamaindex/llama-parse-browser-test
 
+## 0.0.68
+
+### Patch Changes
+
+- @llamaindex/cloud@4.0.13
+
+## 0.0.67
+
+### Patch Changes
+
+- @llamaindex/cloud@4.0.12
+
 ## 0.0.66
 
 ### Patch Changes

e2e/examples/llama-parse-browser/CLAUDE.md

@@ -0,0 +1,111 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with the LlamaParse Browser Test example.
+
+## Package Overview
+
+The `@llamaindex/llama-parse-browser-test` package is a minimal browser-based example that demonstrates how to use LlamaParse (from `@llamaindex/cloud`) in a web browser environment. This serves as both an integration test and a reference implementation for browser compatibility with LlamaIndexTS cloud services.
+
+## Purpose
+
+This example validates that:
+
+- `@llamaindex/cloud` package works correctly in browser environments
+- LlamaParse functionality can be bundled and run in web applications
+- The build process properly handles WASM dependencies and browser-specific requirements
+- TypeScript compilation works with DOM APIs and modern bundler tooling
+
+## Development Commands
+
+- `npm run dev` - Start Vite development server with hot reload
+- `npm run build` - Build for production (TypeScript compilation + Vite build)
+- `npm run preview` - Preview the production build locally
+
+## Architecture
+
+### Build Setup
+
+**Bundler**: Vite 6.x with TypeScript support
+**WASM Support**: Uses `vite-plugin-wasm` for WebAssembly module handling
+**Module System**: ESM-only (`"type": "module"`)
+**Target Environment**: Modern browsers (ES2020+)
+
+### Key Configuration
+
+**Vite Config (`vite.config.ts`):**
+
+- `vite-plugin-wasm` - Enables WASM module imports
+- `ssr.external: ["tiktoken"]` - Excludes tiktoken from SSR bundling (browser-only)
+
+**TypeScript Config (`tsconfig.json`):**
+
+- Extends root monorepo TypeScript configuration
+- DOM and DOM.Iterable libraries enabled for browser APIs
+- Bundler module resolution for optimal Vite integration
+- References `@llamaindex/cloud` package for type checking
+
+### Application Structure
+
+**Entry Point (`src/main.ts`):**
+
+- Imports `LlamaParseReader` from `@llamaindex/cloud`
+- Instantiates the reader to test browser compatibility
+- Minimal DOM manipulation for visual feedback
+
+**Styling (`src/style.css`):**
+
+- Modern CSS with light/dark theme support
+- Responsive design with flexbox layout
+- Clean, minimal UI suitable for testing environment
+
+**HTML (`index.html`):**
+
+- Standard Vite HTML template
+- Single-page application structure
+- Module script loading for ES6 imports
+
+## Dependencies
+
+**Core Dependency:**
+
+- `@llamaindex/cloud` (workspace) - LlamaCloud integration including LlamaParse
+
+**Development Dependencies:**
+
+- `vite` - Modern build tool and development server
+- `vite-plugin-wasm` - WebAssembly support for Vite
+- `typescript` - TypeScript compiler and language support
+
+## Testing Integration
+
+This example functions as an end-to-end test by:
+
+1. **Import Validation**: Verifies `@llamaindex/cloud` can be imported in browser context
+2. **Instantiation Testing**: Tests that `LlamaParseReader` can be created without errors
+3. **Bundle Compatibility**: Ensures the build process handles all dependencies correctly
+4. **Runtime Verification**: Validates the application loads and runs in actual browsers
+
+## Browser Compatibility
+
+The application targets modern browsers with:
+
+- ES2020 language features
+- ES Modules support
+- WebAssembly support (for potential WASM dependencies)
+- Modern DOM APIs
+
+## Development Notes
+
+- **Minimal Implementation**: Keeps the example simple to focus on integration testing
+- **Cloud Service Focus**: Specifically tests browser compatibility with LlamaCloud services
+- **Build Validation**: Ensures the build process works end-to-end without browser-specific issues
+- **WASM Preparation**: Configured for WASM dependencies even if not currently used
+- **Type Safety**: Full TypeScript integration with proper DOM type definitions
+
+## Common Issues
+
+- **WASM Loading**: The `vite-plugin-wasm` handles WebAssembly module loading complexities
+- **SSR Exclusions**: Tiktoken is excluded from SSR to prevent Node.js-specific dependencies in browser builds
+- **Module Resolution**: Uses bundler module resolution for optimal compatibility with modern web tooling
+
+This example serves as a foundation for integrating LlamaIndexTS cloud services into web applications and validates that the core cloud functionality works correctly in browser environments.

e2e/examples/llama-parse-browser/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@llamaindex/llama-parse-browser-test",
   "private": true,
-  "version": "0.0.66",
+  "version": "0.0.68",
   "type": "module",
   "scripts": {
     "dev": "vite",

e2e/examples/nextjs-agent/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @llamaindex/next-agent-test
 
+## 0.1.166
+
+### Patch Changes
+
+- llamaindex@0.11.5
+
+## 0.1.165
+
+### Patch Changes
+
+- llamaindex@0.11.4
+
 ## 0.1.164
 
 ### Patch Changes

e2e/examples/nextjs-agent/CLAUDE.md

@@ -0,0 +1,121 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with the Next.js Agent example in the LlamaIndexTS e2e testing suite.
+
+## Package Overview
+
+The `@llamaindex/next-agent-test` package is a Next.js application example that demonstrates integration between LlamaIndexTS and Next.js, specifically showcasing agent functionality with React Server Components and streaming UI using the Vercel AI SDK.
+
+This example serves as both an integration test for Next.js compatibility and a reference implementation for building LlamaIndex-powered chat applications with Next.js.
+
+## Development Commands
+
+Local development commands:
+
+- `npm run dev` - Start the Next.js development server on http://localhost:3000
+- `npm run build` - Build the application for production
+- `npm run start` - Start the production server
+
+From the workspace root:
+
+- `pnpm build` - Build all packages (required before running this example)
+- `pnpm e2e` - Run e2e tests including this Next.js integration
+
+## Architecture
+
+### Next.js Configuration
+
+The application uses a custom Next.js configuration with the LlamaIndex Next.js plugin:
+
+- `next.config.mjs` imports and applies `withLlamaIndex` from `llamaindex/next`
+- Enables Edge Runtime compatibility for LlamaIndex components
+- Uses Next.js 15 with React 19
+
+### Runtime Environment
+
+- **Edge Runtime**: The main page (`src/app/page.tsx`) exports `runtime = "edge"` for Vercel Edge Runtime compatibility
+- **React Server Components**: Uses Next.js App Router with RSC architecture
+- **Streaming UI**: Integrates Vercel AI SDK's `createStreamableUI` for real-time agent responses
+
+### Key Components
+
+**Main Application (`src/app/page.tsx`):**
+
+- Client component using React's `useFormState` hook
+- Triggers server action `chatWithAgent` with a simple form interface
+- Displays streaming agent responses in real-time
+
+**Server Actions (`src/actions/index.tsx`):**
+
+- `chatWithAgent` function creates an OpenAI agent and handles streaming chat
+- Uses `OpenAIAgent` from `@llamaindex/openai` package
+- Implements streaming response with `createStreamableUI` from AI SDK
+- Accepts question string and previous chat messages as parameters
+
+**Test Page (`src/app/test/page.tsx`):**
+
+- Simple import test that ensures `llamaindex` package loads correctly
+- Serves as a basic smoke test for package compatibility
+
+### Dependencies
+
+**Core Dependencies:**
+
+- `llamaindex` - Main LlamaIndex package (workspace dependency)
+- `next` - Next.js framework (v15.3.0+)
+- `react` & `react-dom` - React 19 for latest features
+- `ai` - Vercel AI SDK for streaming UI components
+
+**Development Dependencies:**
+
+- TypeScript configuration for Next.js development
+- ESLint with Next.js specific rules
+
+## Integration Patterns
+
+### Agent Integration
+
+The example demonstrates how to:
+
+1. Create an OpenAI agent with configurable tools
+2. Handle streaming chat responses in a server action
+3. Integrate with React's form state management
+4. Display real-time streaming responses in the UI
+
+### Next.js Best Practices
+
+- Uses App Router with proper server/client component separation
+- Implements React Server Actions for agent communication
+- Leverages Edge Runtime for optimal performance
+- Follows Next.js 15 conventions with React 19 features
+
+## Testing Role
+
+This example serves multiple testing purposes in the e2e suite:
+
+1. **Next.js Compatibility**: Validates LlamaIndex works with latest Next.js versions
+2. **Edge Runtime Testing**: Ensures agent functionality works in edge environments
+3. **Streaming Integration**: Tests real-time agent responses with AI SDK
+4. **React Server Components**: Validates RSC compatibility with LlamaIndex agents
+5. **Build Integration**: Confirms Next.js build process works with LlamaIndex
+
+## Development Notes
+
+- **Build Dependency**: This example requires the LlamaIndex packages to be built first (`pnpm build` from workspace root)
+- **API Keys**: Real agent functionality requires OpenAI API key in environment variables
+- **Edge Runtime**: The application is configured for edge runtime compatibility, making it suitable for Vercel deployment
+- **Streaming UI**: Demonstrates modern streaming patterns for AI applications
+- **Framework Integration**: Shows best practices for integrating LlamaIndex with React-based frameworks
+
+## Environment Requirements
+
+- Node.js environment with Next.js support
+- OpenAI API key for real agent functionality (optional for basic testing)
+- Compatible with Vercel Edge Runtime and standard Node.js runtime
+
+## Common Workflows
+
+1. **Local Development**: Run `npm run dev` after building workspace packages
+2. **Testing Agent Flow**: Use the simple form interface to test streaming agent responses
+3. **Build Validation**: Run `npm run build` to ensure production build compatibility
+4. **Integration Testing**: Part of e2e test suite validating Next.js + LlamaIndex integration

e2e/examples/nextjs-agent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llamaindex/next-agent-test",
-  "version": "0.1.164",
+  "version": "0.1.166",
   "private": true,
   "scripts": {
     "dev": "next dev",

e2e/examples/nextjs-edge-runtime/CHANGELOG.md

@@ -1,5 +1,17 @@
 # test-edge-runtime
 
+## 0.1.165
+
+### Patch Changes
+
+- llamaindex@0.11.5
+
+## 0.1.164
+
+### Patch Changes
+
+- llamaindex@0.11.4
+
 ## 0.1.163
 
 ### Patch Changes

e2e/examples/nextjs-edge-runtime/CLAUDE.md

@@ -0,0 +1,128 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with the LlamaIndexTS Next.js Edge Runtime example.
+
+## Package Overview
+
+The `@llamaindex/nextjs-edge-runtime-test` package is an end-to-end test example that validates LlamaIndexTS compatibility with Next.js Edge Runtime. This example serves as both a test case and a reference implementation for using LlamaIndex in Vercel Edge Runtime environments.
+
+## Purpose
+
+This example specifically tests:
+
+- LlamaIndex package import compatibility in Edge Runtime
+- Next.js Edge Runtime environment detection
+- Proper runtime configuration for LlamaIndex in serverless edge environments
+- Integration with Next.js 15.x App Router using edge runtime
+
+## Development Commands
+
+Standard Next.js commands:
+
+- `npm run dev` - Start development server
+- `npm run build` - Build for production
+- `npm start` - Start production server
+
+From the workspace root:
+
+- `pnpm build` - Build all packages (required before testing)
+- `pnpm e2e` - Run all e2e tests including this example
+
+## Architecture
+
+### Next.js Configuration
+
+**next.config.mjs:**
+
+- Uses `withLlamaIndex` wrapper from `llamaindex/next` for proper Edge Runtime configuration
+- Applies necessary bundling and polyfill configurations for LlamaIndex compatibility
+
+### Runtime Configuration
+
+**Edge Runtime Setup:**
+
+- Both `src/app/layout.tsx` and `src/app/page.tsx` export `runtime = "edge"`
+- Forces Next.js to use Edge Runtime instead of Node.js runtime
+- Validates LlamaIndex works in constrained serverless environments
+
+### Runtime Validation
+
+**src/utils/llm.ts:**
+
+- Imports the main `llamaindex` package to test compatibility
+- Performs runtime environment validation by checking for `EdgeRuntime` global
+- Throws error if not running in expected Edge Runtime environment
+- Acts as a smoke test for package loading in edge environments
+
+### Application Structure
+
+**App Router Setup:**
+
+- Uses Next.js 13+ App Router with TypeScript
+- Minimal React components for testing runtime compatibility
+- CSS imports to validate bundling works correctly
+- Path aliases configured for `@/*` imports
+
+## Key Features
+
+### Edge Runtime Compatibility
+
+- Tests LlamaIndex package loading in Vercel Edge Runtime
+- Validates proper tree-shaking and bundling for edge environments
+- Ensures no Node.js-specific APIs are accidentally imported
+
+### LlamaIndex Integration
+
+- Uses workspace dependency `llamaindex: "workspace:*"`
+- Leverages `withLlamaIndex` Next.js plugin for proper configuration
+- Tests base package import without specific providers
+
+### Environment Detection
+
+- Runtime environment validation ensures code runs in expected context
+- Prevents deployment issues by catching runtime mismatches early
+- Provides clear error messages for debugging
+
+## Dependencies
+
+**Core Dependencies:**
+
+- `llamaindex` - Main LlamaIndexTS package (workspace dependency)
+- `next` - Next.js framework (v15.3.0)
+- `react` & `react-dom` - React framework (v19.x)
+
+**Development Dependencies:**
+
+- TypeScript types for Node.js, React, and React DOM
+- TypeScript compiler for type checking
+
+## Development Notes
+
+- **Build Dependency**: Ensure `pnpm build` is run from workspace root before testing
+- **Edge Runtime Only**: This example is specifically designed for Edge Runtime, not Node.js runtime
+- **Minimal Implementation**: Intentionally minimal to isolate Edge Runtime compatibility testing
+- **Import Testing**: The `src/utils/llm.ts` file serves as an import compatibility test
+- **Bundle Size**: Edge Runtime has size constraints, so this tests LlamaIndex bundle compatibility
+
+## Testing Purpose
+
+This example validates that:
+
+1. LlamaIndex packages can be imported in Edge Runtime environments
+2. Next.js configuration works correctly with LlamaIndex
+3. Runtime environment detection functions properly
+4. Bundle size and tree-shaking work for edge deployments
+5. No Node.js-specific APIs are inadvertently used
+
+## Common Issues
+
+- **Runtime Detection Failures**: If `EdgeRuntime` is not detected, check Next.js configuration
+- **Import Errors**: Ensure workspace packages are built before running
+- **Bundle Size**: Edge Runtime has memory/size limits that may affect large imports
+- **API Compatibility**: Some LlamaIndex features may not work in Edge Runtime due to API limitations
+
+## Related Examples
+
+- `../nextjs-node-runtime/` - Node.js runtime equivalent
+- `../cloudflare-worker-agent/` - Cloudflare Workers edge runtime
+- `../nextjs-agent/` - Full Next.js agent implementation

e2e/examples/nextjs-edge-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llamaindex/nextjs-edge-runtime-test",
-  "version": "0.1.163",
+  "version": "0.1.165",
   "private": true,
   "scripts": {
     "dev": "next dev",

e2e/examples/nextjs-node-runtime/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @llamaindex/next-node-runtime
 
+## 0.1.33
+
+### Patch Changes
+
+- llamaindex@0.11.5
+- @llamaindex/huggingface@0.1.13
+- @llamaindex/readers@3.1.7
+
+## 0.1.32
+
+### Patch Changes
+
+- @llamaindex/huggingface@0.1.12
+- llamaindex@0.11.4
+- @llamaindex/readers@3.1.6
+
 ## 0.1.31
 
 ### Patch Changes

e2e/examples/nextjs-node-runtime/CLAUDE.md

@@ -0,0 +1,129 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with the Next.js Node Runtime example package.
+
+## Package Overview
+
+The `@llamaindex/next-node-runtime-test` package is an end-to-end test example that demonstrates LlamaIndexTS integration with Next.js running on the Node.js runtime. This example validates that LlamaIndex packages work correctly in a Next.js App Router environment with server-side rendering and server actions.
+
+## Development Commands
+
+From this directory:
+
+- `npm run dev` - Start development server on http://localhost:3000
+- `npm run build` - Build the Next.js application
+- `npm run start` - Start production server
+
+From the e2e root directory:
+
+- `pnpm e2e` - Run all e2e tests including this example
+
+## Application Structure
+
+### Configuration Files
+
+- `next.config.mjs` - Next.js configuration with LlamaIndex integration using `withLlamaIndex()`
+- `tsconfig.json` - TypeScript configuration for Next.js with App Router
+- `package.json` - Dependencies including `llamaindex`, `@llamaindex/huggingface`, and `@llamaindex/readers`
+
+### Source Structure
+
+**App Router Pages:**
+
+- `src/app/page.tsx` - Home page that demonstrates tokenizer usage with `runtime = "nodejs"`
+- `src/app/layout.tsx` - Root layout component with Inter font
+
+**API Routes:**
+
+- `src/app/api/openai/route.ts` - POST endpoint that calls OpenAI server action
+
+**Server Actions:**
+
+- `src/actions/openai.ts` - Server action demonstrating full LlamaIndex workflow with OpenAI agent
+
+**Utilities:**
+
+- `src/utils/tokenizer.ts` - Runtime validation and tokenization example
+
+## Key Features Demonstrated
+
+### 1. Runtime Validation (`src/utils/tokenizer.ts`)
+
+Tests that the application runs in Node.js runtime (not Edge):
+
+```typescript
+// @ts-expect-error EdgeRuntime is not defined in type
+if (typeof EdgeRuntime === "string") {
+  throw new Error("Expected to not run in EdgeRuntime");
+}
+```
+
+Uses LlamaIndex tokenizers:
+
+```typescript
+import { Tokenizers, tokenizers } from "@llamaindex/env/tokenizers";
+```
+
+### 2. OpenAI Agent Integration (`src/actions/openai.ts`)
+
+Demonstrates a complete LlamaIndex workflow:
+
+- **LLM Configuration**: OpenAI GPT-4o with API key management
+- **Embedding Model**: HuggingFace BAAI/bge-small-en-v1.5 embeddings
+- **Document Loading**: SimpleDirectoryReader for local file processing
+- **Vector Index**: VectorStoreIndex creation from documents
+- **Tool Integration**: Query engine as a tool for the agent
+- **Agent Creation**: OpenAIAgent with tools for conversational AI
+- **Callback Handling**: Event listeners for tool calls and results
+
+### 3. Next.js Integration
+
+- **Server Actions**: "use server" directive for server-side LlamaIndex operations
+- **API Routes**: RESTful endpoint for external integration
+- **App Router**: Modern Next.js routing with TypeScript support
+- **LlamaIndex Plugin**: `withLlamaIndex()` wrapper for proper bundling
+
+## Dependencies
+
+**Core LlamaIndex:**
+
+- `llamaindex` - Main LlamaIndex package
+- `@llamaindex/huggingface` - HuggingFace embedding models
+- `@llamaindex/readers` - Document readers including SimpleDirectoryReader
+
+**Next.js Stack:**
+
+- `next@^15.3.0` - Next.js framework
+- `react@19.0.0` & `react-dom@19.0.0` - React runtime
+- `typescript@^5.7.3` - TypeScript support
+
+## Testing Purpose
+
+This example serves as an integration test for:
+
+1. **Node.js Runtime Compatibility**: Ensures LlamaIndex works in Next.js Node.js runtime
+2. **Server Actions**: Validates server-side LlamaIndex operations
+3. **Document Processing**: Tests file reading and vector indexing
+4. **Agent Workflows**: Validates OpenAI agent with tool integration
+5. **Bundling**: Ensures proper webpack bundling with `withLlamaIndex()`
+6. **API Integration**: Tests REST API endpoints with LlamaIndex backend
+
+## Environment Variables
+
+- `NEXT_PUBLIC_OPENAI_KEY` - OpenAI API key (falls back to "FAKE_KEY_TO_PASS_TESTS" for testing)
+
+## Development Notes
+
+- **Runtime Enforcement**: Explicitly sets `runtime = "nodejs"` in page components
+- **Error Handling**: Comprehensive try-catch in server actions
+- **Callback Management**: Event listeners for debugging tool interactions
+- **Testing Compatibility**: Fake API key fallback for automated testing
+- **Bundle Optimization**: Uses `withLlamaIndex()` for proper webpack configuration
+- **Type Safety**: Full TypeScript support with Next.js type definitions
+
+## Common Workflows
+
+1. **Local Development**: `npm run dev` to start development server with hot reload
+2. **Production Testing**: `npm run build && npm run start` to test production build
+3. **Integration Testing**: Run from e2e root with `pnpm e2e` for automated validation
+4. **Agent Testing**: POST to `/api/openai` endpoint with query payload for agent responses

e2e/examples/nextjs-node-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llamaindex/next-node-runtime-test",
-  "version": "0.1.31",
+  "version": "0.1.33",
   "private": true,
   "scripts": {
     "dev": "next dev",

e2e/examples/vite-import-llamaindex/CHANGELOG.md

@@ -1,5 +1,17 @@
 # vite-import-llamaindex
 
+## 0.0.32
+
+### Patch Changes
+
+- llamaindex@0.11.5
+
+## 0.0.31
+
+### Patch Changes
+
+- llamaindex@0.11.4
+
 ## 0.0.30
 
 ### Patch Changes

e2e/examples/vite-import-llamaindex/CLAUDE.md

@@ -0,0 +1,108 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with the vite-import-llamaindex example package.
+
+## Package Overview
+
+The `vite-import-llamaindex` package is a minimal Vite-based compatibility test that validates LlamaIndexTS can be properly imported and bundled in browser environments using Vite. This example serves as both an integration test and a demonstration of bundle size validation.
+
+## Purpose
+
+This example specifically tests:
+
+- **Vite Bundler Compatibility**: Ensures LlamaIndexTS works correctly with Vite's bundling system
+- **Browser Import Validation**: Validates that the `llamaindex` package can be imported in browser-compatible builds
+- **Bundle Size Monitoring**: Uses size-limit to track and validate bundle output size
+- **Dual Module Support**: Tests both ESM and CJS output formats through Vite's library mode
+
+## Development Commands
+
+Local package commands:
+
+- `npm run build` - Build the example using Vite library mode
+- `npm run size-limit` - Check bundle size against configured limits
+
+From the root directory:
+
+- `pnpm build` - Build all packages (required before testing)
+- `pnpm e2e` - Run all e2e tests including this example
+
+## Project Structure
+
+```
+vite-import-llamaindex/
+├── src/
+│   └── main.ts          # Main entry point that imports llamaindex
+├── public/
+│   └── vite.svg         # Vite logo asset
+├── package.json         # Package configuration with size-limit setup
+├── vite.config.ts       # Vite library build configuration
+├── tsconfig.json        # TypeScript configuration
+└── CHANGELOG.md         # Version history
+```
+
+## Configuration Details
+
+### Vite Configuration (`vite.config.ts`)
+
+- **Library Mode**: Configured to build as a library with dual format output (ESM + CJS)
+- **Entry Point**: `src/main.ts` as the main entry
+- **Output Name**: `LlamaIndexImportTest`
+- **Formats**: Both ES modules and CommonJS for compatibility testing
+
+### TypeScript Configuration (`tsconfig.json`)
+
+- **Target**: ES2020 for modern browser compatibility
+- **Module System**: ESNext with bundler resolution for Vite
+- **Strict Mode**: Enabled with comprehensive linting rules
+- **DOM Types**: Includes DOM and DOM.Iterable for browser environment
+
+### Bundle Size Monitoring
+
+The package uses `size-limit` to monitor bundle size:
+
+```json
+"size-limit": [
+  {
+    "path": "dist/LlamaIndexImportTest.js"
+  }
+]
+```
+
+This ensures the bundled output remains within reasonable size constraints for browser applications.
+
+## Test Approach
+
+The test validates:
+
+1. **Import Success**: The `llamaindex` package can be imported without errors
+2. **Bundle Generation**: Vite can successfully bundle the code into browser-compatible output
+3. **Size Validation**: The resulting bundle meets size requirements
+4. **Module Compatibility**: Both ESM and CJS outputs are generated correctly
+
+## Dependencies
+
+- **`llamaindex`**: Workspace dependency for testing the main package
+- **`vite`**: Build tool and bundler
+- **`typescript`**: TypeScript compiler
+- **`@size-limit/preset-big-lib`**: Bundle size analysis for libraries
+- **`size-limit`**: Bundle size monitoring tool
+
+## Development Notes
+
+- **Build Dependency**: This example depends on the main `llamaindex` package being built first
+- **Browser Focus**: Specifically tests browser compatibility, not Node.js environments
+- **Size Monitoring**: Bundle size is actively monitored to prevent bloat
+- **Minimal Example**: Kept intentionally simple to isolate bundling issues
+- **Integration Test**: Serves as both an example and an automated test in the e2e suite
+
+## Common Issues
+
+1. **Build Failures**: Ensure `pnpm build` is run from the root before testing this example
+2. **Size Limit Violations**: If bundle size exceeds limits, investigate dependency bloat
+3. **Import Errors**: Check that the `llamaindex` package exports are browser-compatible
+4. **TypeScript Errors**: Verify TypeScript configuration matches Vite requirements
+
+## Relationship to E2E Testing
+
+This example is part of the broader e2e testing suite and validates that LlamaIndexTS maintains browser compatibility. It ensures that when users integrate LlamaIndexTS with Vite in their own projects, they won't encounter bundling or import issues.

e2e/examples/vite-import-llamaindex/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vite-import-llamaindex",
   "private": true,
-  "version": "0.0.30",
+  "version": "0.0.32",
   "type": "module",
   "scripts": {
     "build": "vite build",

e2e/examples/waku-query-engine/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @llamaindex/waku-query-engine-test
 
+## 0.0.166
+
+### Patch Changes
+
+- llamaindex@0.11.5
+
+## 0.0.165
+
+### Patch Changes
+
+- llamaindex@0.11.4
+
 ## 0.0.164
 
 ### Patch Changes

e2e/examples/waku-query-engine/CLAUDE.md

@@ -0,0 +1,131 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with the LlamaIndexTS Waku Query Engine example.
+
+## Package Overview
+
+The `@llamaindex/waku-query-engine-test` package demonstrates LlamaIndexTS integration with the Waku React framework. This example showcases how to build a document query interface using LlamaIndex's VectorStoreIndex and QueryEngine capabilities within a Waku application that supports both static rendering and server actions.
+
+## Development Commands
+
+- `npm run dev` - Start Waku development server
+- `npm run build` - Build the application for production
+- `npm run start` - Start the production server
+
+## Architecture
+
+### Framework Integration
+
+This example uses **Waku 0.22.2**, a lightweight React framework that supports:
+
+- React Server Components (RSC)
+- Server actions with "use server" directive
+- Static site generation with `render: "static"` config
+- Client-side hydration with "use client" components
+
+### LlamaIndex Integration
+
+The core LlamaIndex functionality is implemented in `src/actions.ts`:
+
+**Key Components:**
+
+- **Document Loading**: Reads text from `node_modules/llamaindex/examples/abramov.txt`
+- **Vector Index**: Creates embeddings using `VectorStoreIndex.fromDocuments()`
+- **Query Engine**: Provides semantic search capabilities via `index.asQueryEngine()`
+- **Lazy Loading**: QueryEngine is initialized once and cached for subsequent requests
+
+**Data Flow:**
+
+1. User inputs question in chat interface (`src/components/chat.tsx`)
+2. Form submission triggers server action (`chatWithAI`)
+3. Server action queries the VectorStoreIndex
+4. Response is returned and displayed in the UI
+
+### Component Structure
+
+**Server Components:**
+
+- `src/pages/_layout.tsx` - Root layout with static metadata
+- `src/pages/index.tsx` - Home page with static rendering config
+- `src/components/header.tsx` - Navigation header
+- `src/components/footer.tsx` - Site footer
+
+**Client Components:**
+
+- `src/components/chat.tsx` - Interactive chat interface with form state management
+
+### Styling
+
+- **TailwindCSS 4.1.4** for utility-first styling
+- **PostCSS** for CSS processing
+- **Nunito font** via Google Fonts
+- Responsive design with mobile-first approach
+
+## Dependencies
+
+**Core Dependencies:**
+
+- `@llamaindex/env` - Runtime environment compatibility
+- `llamaindex` - Main LlamaIndexTS package for document indexing and querying
+- `waku` - React framework for SSR/SSG
+- `react` & `react-dom` - React 19.0.0 with experimental features
+- `react-server-dom-webpack` - React Server Components support
+
+**Development Dependencies:**
+
+- `typescript` - TypeScript 5.7.3 with strict mode
+- `tailwindcss` & `@tailwindcss/postcss` - Styling framework
+- `rollup` - Build tool used by Waku
+
+## TypeScript Configuration
+
+- **Target**: ESNext with modern features
+- **Module**: ESNext with bundler resolution
+- **React**: Experimental types for React 19 features
+- **Strict**: Full TypeScript strict mode enabled
+
+## Key Features Demonstrated
+
+1. **Server Actions Integration**: Seamless LlamaIndex queries via Waku server actions
+2. **Document RAG**: Retrieval-Augmented Generation using vector embeddings
+3. **Static Generation**: Pages are statically rendered while maintaining interactive features
+4. **React 19 Features**: Uses latest React with experimental types
+5. **Modern Styling**: TailwindCSS 4.x with PostCSS integration
+
+## Testing Context
+
+This example serves as an end-to-end test for:
+
+- LlamaIndexTS compatibility with Waku framework
+- React Server Components integration
+- Vector store and query engine functionality
+- Server action patterns with LlamaIndex
+- Build and deployment workflows
+
+## Development Notes
+
+- **File Loading**: Uses `@llamaindex/env` fs abstraction for cross-platform file access
+- **Query Caching**: QueryEngine is lazily loaded and cached for performance
+- **Error Handling**: Basic error handling in server actions and form submissions
+- **Bundle Size**: Waku's optimized bundling ensures minimal client-side JavaScript
+- **Runtime Support**: Compatible with Node.js runtime environments
+
+## Common Patterns
+
+**Adding New Documents:**
+
+1. Place document files in accessible location
+2. Update `lazyLoadQueryEngine()` to load additional documents
+3. Rebuild vector index with new document set
+
+**Extending Chat Interface:**
+
+1. Modify `Chat` component for enhanced UI features
+2. Update `chatWithAI` server action for additional processing
+3. Add error states and loading indicators as needed
+
+**Styling Updates:**
+
+1. Modify TailwindCSS classes in components
+2. Update `tailwind.config.js` for custom configurations
+3. Use `src/styles.css` for global styles

e2e/examples/waku-query-engine/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llamaindex/waku-query-engine-test",
-  "version": "0.0.164",
+  "version": "0.0.166",
   "type": "module",
   "private": true,
   "scripts": {

examples/CHANGELOG.md

@@ -1,5 +1,109 @@
 # examples
 
+## 0.3.19
+
+### Patch Changes
+
+- Updated dependencies [766054b]
+- Updated dependencies [5346623]
+- Updated dependencies [71598f8]
+  - @llamaindex/workflow@1.1.6
+  - @llamaindex/google@0.3.6
+  - @llamaindex/core@0.6.9
+  - llamaindex@0.11.5
+  - @llamaindex/cloud@4.0.13
+  - @llamaindex/node-parser@2.0.9
+  - @llamaindex/anthropic@0.3.11
+  - @llamaindex/assemblyai@0.1.8
+  - @llamaindex/clip@0.0.59
+  - @llamaindex/cohere@0.0.23
+  - @llamaindex/deepinfra@0.0.59
+  - @llamaindex/discord@0.1.8
+  - @llamaindex/huggingface@0.1.13
+  - @llamaindex/jinaai@0.0.19
+  - @llamaindex/mistral@0.1.9
+  - @llamaindex/mixedbread@0.0.23
+  - @llamaindex/notion@0.1.8
+  - @llamaindex/ollama@0.1.9
+  - @llamaindex/openai@0.4.3
+  - @llamaindex/perplexity@0.0.16
+  - @llamaindex/portkey-ai@0.0.51
+  - @llamaindex/replicate@0.0.51
+  - @llamaindex/astra@0.0.23
+  - @llamaindex/azure@0.1.20
+  - @llamaindex/chroma@0.0.23
+  - @llamaindex/elastic-search@0.1.9
+  - @llamaindex/firestore@1.0.16
+  - @llamaindex/milvus@0.1.18
+  - @llamaindex/mongodb@0.0.24
+  - @llamaindex/pinecone@0.1.9
+  - @llamaindex/postgres@0.0.52
+  - @llamaindex/qdrant@0.1.19
+  - @llamaindex/supabase@0.1.8
+  - @llamaindex/upstash@0.0.23
+  - @llamaindex/weaviate@0.0.23
+  - @llamaindex/vercel@0.1.9
+  - @llamaindex/voyage-ai@1.0.15
+  - @llamaindex/readers@3.1.7
+  - @llamaindex/tools@0.0.14
+  - @llamaindex/deepseek@0.0.19
+  - @llamaindex/fireworks@0.0.19
+  - @llamaindex/groq@0.0.74
+  - @llamaindex/together@0.0.19
+  - @llamaindex/vllm@0.0.45
+  - @llamaindex/xai@0.0.6
+
+## 0.3.18
+
+### Patch Changes
+
+- Updated dependencies [c927457]
+  - @llamaindex/anthropic@0.3.10
+  - @llamaindex/openai@0.4.2
+  - @llamaindex/core@0.6.8
+  - @llamaindex/clip@0.0.58
+  - @llamaindex/deepinfra@0.0.58
+  - @llamaindex/deepseek@0.0.18
+  - @llamaindex/fireworks@0.0.18
+  - @llamaindex/groq@0.0.73
+  - @llamaindex/huggingface@0.1.12
+  - @llamaindex/jinaai@0.0.18
+  - @llamaindex/perplexity@0.0.15
+  - @llamaindex/azure@0.1.19
+  - @llamaindex/elastic-search@0.1.8
+  - @llamaindex/milvus@0.1.17
+  - @llamaindex/qdrant@0.1.18
+  - @llamaindex/supabase@0.1.7
+  - @llamaindex/together@0.0.18
+  - @llamaindex/vllm@0.0.44
+  - @llamaindex/xai@0.0.5
+  - @llamaindex/cloud@4.0.12
+  - llamaindex@0.11.4
+  - @llamaindex/node-parser@2.0.8
+  - @llamaindex/assemblyai@0.1.7
+  - @llamaindex/cohere@0.0.22
+  - @llamaindex/discord@0.1.7
+  - @llamaindex/google@0.3.5
+  - @llamaindex/mistral@0.1.8
+  - @llamaindex/mixedbread@0.0.22
+  - @llamaindex/notion@0.1.7
+  - @llamaindex/ollama@0.1.8
+  - @llamaindex/portkey-ai@0.0.50
+  - @llamaindex/replicate@0.0.50
+  - @llamaindex/astra@0.0.22
+  - @llamaindex/chroma@0.0.22
+  - @llamaindex/firestore@1.0.15
+  - @llamaindex/mongodb@0.0.23
+  - @llamaindex/pinecone@0.1.8
+  - @llamaindex/postgres@0.0.51
+  - @llamaindex/upstash@0.0.22
+  - @llamaindex/weaviate@0.0.22
+  - @llamaindex/vercel@0.1.8
+  - @llamaindex/voyage-ai@1.0.14
+  - @llamaindex/readers@3.1.6
+  - @llamaindex/tools@0.0.13
+  - @llamaindex/workflow@1.1.5
+
 ## 0.3.17
 
 ### Patch Changes

examples/CLAUDE.md

@@ -0,0 +1,172 @@
+# CLAUDE.md - Examples Package
+
+This directory contains comprehensive examples demonstrating LlamaIndex.TS functionality across different use cases and integrations.
+
+## Running Examples
+
+All examples are executable TypeScript files that can be run directly:
+
+```bash
+# Run a specific example
+npx tsx ./rag/starter.ts
+npx tsx ./agents/agent/single-agent.ts
+npx tsx ./models/openai/openai.ts
+
+# Or use the package script
+npm start  # runs ./starter.ts (if it exists)
+```
+
+## Environment Setup
+
+Most examples require API keys. Set environment variables before running:
+
+```bash
+export OPENAI_API_KEY="sk-..."
+export ANTHROPIC_API_KEY="sk-..."
+export PINECONE_API_KEY="..."
+# Add other provider keys as needed
+```
+
+## Example Categories
+
+### Agents (`agents/`)
+
+Demonstrates agent functionality and workflows:
+
+- **`agent/`** - Modern agent implementations using `@llamaindex/workflow`
+  - `single-agent.ts` - Basic agent with tool usage
+  - `multiple-agents.ts` - Multi-agent coordination
+  - `blog-writer.ts` - Content generation agent
+  - `with-anthropic.ts`, `with-ollama.ts` - Provider-specific agents
+- **`workflow/`** - Workflow orchestration examples
+- **`toolsStream.ts`** - Streaming tool interactions
+
+### RAG (Retrieval-Augmented Generation) (`rag/`)
+
+Core RAG functionality examples:
+
+- `starter.ts` - Basic RAG setup with VectorStoreIndex
+- `chatEngine.ts` - Conversational RAG interface
+- `chat-engine/` - Different chat engine implementations
+- `extractors/` - Metadata extraction examples
+- `nodeParser/` - Custom text chunking strategies
+- `split.ts`, `sentenceWindow.ts` - Text processing techniques
+
+### Models (`models/`)
+
+Provider-specific LLM and embedding examples:
+
+- **`openai/`** - OpenAI integration (chat, completions, embeddings, multimodal)
+- **`anthropic/`** - Claude models with streaming and caching
+- **`gemini/`** - Google Gemini including live API examples
+- **`ollama/`**, **`groq/`**, **`mistral/`** - Alternative LLM providers
+- **`rerankers/`** - Result reranking implementations
+
+### Storage (`storage/`)
+
+Vector store and database integrations:
+
+- **`pinecone-vector-store/`** - Pinecone setup and querying
+- **`chromadb/`**, **`qdrantdb/`**, **`weaviate/`** - Alternative vector stores
+- **`mongodb/`**, **`pg/`**, **`firestore/`** - Database integrations
+- **`metadata-filter/`** - Filtering and search parameters
+
+### Multimodal (`multimodal/`)
+
+Vision and multimodal capabilities:
+
+- `chat.ts` - Image analysis with chat
+- `load.ts`, `retrieve.ts` - Multimodal document processing
+- `clip.ts` - CLIP embeddings for images
+
+### Readers (`readers/`)
+
+Document ingestion from various sources:
+
+- `src/` - File format readers (PDF, DOCX, CSV, JSON, HTML)
+- `llamaparse.ts` - LlamaParse document processing
+- `discord/`, `notion/`, `assemblyai/` - Platform-specific readers
+
+### Cloud (`cloud/`)
+
+LlamaCloud integration examples:
+
+- `chat.ts`, `query.ts` - Cloud-based RAG
+- `from-documents.ts` - Document upload to cloud
+
+### Deprecated (`deprecated/`)
+
+Legacy agent implementations for reference (prefer `agents/agent/` for new code).
+
+## Key Development Patterns
+
+### Example Structure
+
+Most examples follow this pattern:
+
+```typescript
+import { ... } from "llamaindex";
+import { ... } from "@llamaindex/provider";
+
+async function main() {
+  // Setup (API keys, configuration)
+  // Create components (LLM, embeddings, vector store)
+  // Build index or engine
+  // Execute query/chat
+  // Output results
+}
+
+main().catch(console.error);
+```
+
+### Provider Imports
+
+Examples use modular provider imports:
+
+```typescript
+// Specific provider packages
+import { OpenAI } from "@llamaindex/openai";
+import { claude } from "@llamaindex/anthropic";
+
+// Core functionality
+import { VectorStoreIndex, Document } from "llamaindex";
+```
+
+### Error Handling
+
+Include proper error handling and API key validation:
+
+```typescript
+if (!process.env.OPENAI_API_KEY) {
+  console.log("API key required");
+  process.exit(1);
+}
+```
+
+## Dependencies
+
+The examples package includes all major LlamaIndex.TS providers and integrations. Key dependencies:
+
+- **Core**: `llamaindex`, `@llamaindex/core`
+- **Providers**: All LLM, embedding, and vector store providers
+- **Tools**: `@llamaindex/workflow`, `@llamaindex/tools`
+- **Utilities**: `tsx` for TypeScript execution, `dotenv` for environment variables
+
+## Usage Notes
+
+1. **Build First**: Some examples may require building the packages first: `pnpm build`
+2. **Data Files**: Many examples reference files in `./data/` directory
+3. **API Costs**: Be aware that running examples will consume API credits
+4. **Environment**: Examples are designed to run in Node.js environment
+5. **Interactive Examples**: Some examples include readline interfaces for interactive testing
+
+## Creating New Examples
+
+When adding new examples:
+
+1. Follow the established directory structure by category
+2. Use descriptive filenames that indicate functionality
+3. Include proper imports from modular packages
+4. Add error handling and environment validation
+5. Include comments explaining key concepts
+6. Test with minimal required dependencies

examples/models/anthropic/chat-with-file.ts

@@ -25,7 +25,7 @@ async function main() {
           },
           {
             type: "file",
-            data: Uint8Array.from(fs.readFileSync("./data/manga.pdf")),
+            data: fs.readFileSync("./data/manga.pdf").toString("base64"),
             mimeType: "application/pdf",
           },
         ],

examples/models/gemini/chat.ts

@@ -32,7 +32,7 @@ import fs from "fs";
           },
           {
             type: "file",
-            data: Uint8Array.from(fs.readFileSync("./data/manga.pdf")),
+            data: fs.readFileSync("./data/manga.pdf").toString("base64"),
             mimeType: "application/pdf",
           },
         ],

examples/models/openai/openai.ts

@@ -26,7 +26,7 @@ import fs from "fs";
           },
           {
             type: "file",
-            data: new Uint8Array(fs.readFileSync("./data/manga.pdf")),
+            data: fs.readFileSync("./data/manga.pdf").toString("base64"),
             mimeType: "application/pdf",
           },
         ],

examples/models/openai/responses/chat-with-file.ts

@@ -21,7 +21,7 @@ async function main() {
           },
           {
             type: "file",
-            data: Uint8Array.from(fs.readFileSync("./data/manga.pdf")),
+            data: fs.readFileSync("./data/manga.pdf").toString("base64"),
             mimeType: "application/pdf",
           },
         ],

examples/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llamaindex/examples",
-  "version": "0.3.17",
+  "version": "0.3.19",
   "private": true,
   "scripts": {
     "lint": "eslint .",
@@ -11,51 +11,51 @@
     "@azure/cosmos": "^4.1.1",
     "@azure/identity": "^4.4.1",
     "@azure/search-documents": "^12.1.0",
-    "@llamaindex/anthropic": "^0.3.8",
-    "@llamaindex/assemblyai": "^0.1.6",
-    "@llamaindex/astra": "^0.0.21",
-    "@llamaindex/azure": "^0.1.17",
-    "@llamaindex/chroma": "^0.0.21",
-    "@llamaindex/clip": "^0.0.57",
-    "@llamaindex/cloud": "^4.0.10",
-    "@llamaindex/cohere": "^0.0.21",
-    "@llamaindex/core": "^0.6.7",
-    "@llamaindex/deepinfra": "^0.0.57",
-    "@llamaindex/deepseek": "^0.0.17",
-    "@llamaindex/discord": "^0.1.6",
-    "@llamaindex/elastic-search": "^0.1.7",
+    "@llamaindex/anthropic": "^0.3.11",
+    "@llamaindex/assemblyai": "^0.1.8",
+    "@llamaindex/astra": "^0.0.23",
+    "@llamaindex/azure": "^0.1.20",
+    "@llamaindex/chroma": "^0.0.23",
+    "@llamaindex/clip": "^0.0.59",
+    "@llamaindex/cloud": "^4.0.13",
+    "@llamaindex/cohere": "^0.0.23",
+    "@llamaindex/core": "^0.6.9",
+    "@llamaindex/deepinfra": "^0.0.59",
+    "@llamaindex/deepseek": "^0.0.19",
+    "@llamaindex/discord": "^0.1.8",
+    "@llamaindex/elastic-search": "^0.1.9",
     "@llamaindex/env": "^0.1.30",
-    "@llamaindex/firestore": "^1.0.14",
-    "@llamaindex/fireworks": "^0.0.17",
-    "@llamaindex/google": "^0.3.3",
-    "@llamaindex/groq": "^0.0.72",
-    "@llamaindex/huggingface": "^0.1.11",
-    "@llamaindex/jinaai": "^0.0.17",
-    "@llamaindex/milvus": "^0.1.16",
-    "@llamaindex/mistral": "^0.1.7",
-    "@llamaindex/mixedbread": "^0.0.21",
-    "@llamaindex/mongodb": "^0.0.22",
-    "@llamaindex/node-parser": "^2.0.7",
-    "@llamaindex/notion": "^0.1.6",
-    "@llamaindex/ollama": "^0.1.7",
-    "@llamaindex/openai": "^0.4.1",
-    "@llamaindex/perplexity": "^0.0.14",
-    "@llamaindex/pinecone": "^0.1.7",
-    "@llamaindex/portkey-ai": "^0.0.49",
-    "@llamaindex/postgres": "^0.0.50",
-    "@llamaindex/qdrant": "^0.1.16",
-    "@llamaindex/readers": "^3.1.5",
-    "@llamaindex/replicate": "^0.0.49",
-    "@llamaindex/supabase": "^0.1.6",
-    "@llamaindex/together": "^0.0.17",
-    "@llamaindex/tools": "^0.0.12",
-    "@llamaindex/upstash": "^0.0.21",
-    "@llamaindex/vercel": "^0.1.7",
-    "@llamaindex/vllm": "^0.0.43",
-    "@llamaindex/voyage-ai": "^1.0.13",
-    "@llamaindex/weaviate": "^0.0.21",
-    "@llamaindex/workflow": "^1.1.4",
-    "@llamaindex/xai": "workspace:^0.0.4",
+    "@llamaindex/firestore": "^1.0.16",
+    "@llamaindex/fireworks": "^0.0.19",
+    "@llamaindex/google": "^0.3.6",
+    "@llamaindex/groq": "^0.0.74",
+    "@llamaindex/huggingface": "^0.1.13",
+    "@llamaindex/jinaai": "^0.0.19",
+    "@llamaindex/milvus": "^0.1.18",
+    "@llamaindex/mistral": "^0.1.9",
+    "@llamaindex/mixedbread": "^0.0.23",
+    "@llamaindex/mongodb": "^0.0.24",
+    "@llamaindex/node-parser": "^2.0.9",
+    "@llamaindex/notion": "^0.1.8",
+    "@llamaindex/ollama": "^0.1.9",
+    "@llamaindex/openai": "^0.4.3",
+    "@llamaindex/perplexity": "^0.0.16",
+    "@llamaindex/pinecone": "^0.1.9",
+    "@llamaindex/portkey-ai": "^0.0.51",
+    "@llamaindex/postgres": "^0.0.52",
+    "@llamaindex/qdrant": "^0.1.19",
+    "@llamaindex/readers": "^3.1.7",
+    "@llamaindex/replicate": "^0.0.51",
+    "@llamaindex/supabase": "^0.1.8",
+    "@llamaindex/together": "^0.0.19",
+    "@llamaindex/tools": "^0.0.14",
+    "@llamaindex/upstash": "^0.0.23",
+    "@llamaindex/vercel": "^0.1.9",
+    "@llamaindex/vllm": "^0.0.45",
+    "@llamaindex/voyage-ai": "^1.0.15",
+    "@llamaindex/weaviate": "^0.0.23",
+    "@llamaindex/workflow": "^1.1.6",
+    "@llamaindex/xai": "workspace:^0.0.6",
     "@notionhq/client": "^2.2.15",
     "@pinecone-database/pinecone": "^4.0.0",
     "@vercel/postgres": "^0.10.0",
@@ -64,7 +64,7 @@
     "commander": "^12.1.0",
     "dotenv": "^16.4.5",
     "js-tiktoken": "^1.0.14",
-    "llamaindex": "^0.11.2",
+    "llamaindex": "^0.11.5",
     "mongodb": "6.7.0",
     "postgres": "^3.4.4",
     "wikipedia": "^2.1.2",

examples/storage/azure/azure/CLAUDE.md

@@ -0,0 +1,192 @@
+# CLAUDE.md - Azure AI Search Vector Store Example
+
+This example demonstrates how to use Azure AI Search as a vector store backend with LlamaIndex.TS, including Azure OpenAI integration for LLM and embedding models.
+
+## Overview
+
+This example showcases:
+
+- **Azure OpenAI integration** for both LLM and embedding models
+- **Azure AI Search vector store** configuration and management
+- **Document ingestion** from local files
+- **Multiple search modes** (vector, hybrid, semantic hybrid)
+- **Metadata filtering** (with known limitations)
+- **Index management** strategies
+- **Authentication** using Azure AD credentials
+
+## Environment Setup
+
+Create a `.env` file with the following variables:
+
+```bash
+# Azure AI Search
+AZURE_AI_SEARCH_ENDPOINT=https://your-search-service.search.windows.net
+AZURE_AI_SEARCH_KEY=your-search-key
+
+# Azure OpenAI
+AZURE_OPENAI_ENDPOINT=https://your-openai-resource.openai.azure.com/
+AZURE_DEPLOYMENT_NAME=gpt-4
+EMBEDDING_MODEL=text-embedding-ada-002
+AZURE_API_VERSION=2024-09-01-preview
+```
+
+## Authentication
+
+The example uses `DefaultAzureCredential` for authentication, which requires proper Azure RBAC setup:
+
+```typescript
+const credential = new DefaultAzureCredential();
+const azureADTokenProvider = getBearerTokenProvider(
+  credential,
+  "https://cognitiveservices.azure.com/.default",
+);
+```
+
+Alternative: Use API keys by uncommenting the `key` parameter in vector store configuration.
+
+## Key Components
+
+### Azure OpenAI Setup
+
+```typescript
+Settings.llm = new AzureOpenAI({
+  azureADTokenProvider,
+  deployment: process.env.AZURE_DEPLOYMENT_NAME,
+});
+Settings.embedModel = new AzureOpenAIEmbedding({
+  azureADTokenProvider,
+  deployment: process.env.EMBEDDING_MODEL,
+});
+```
+
+### Vector Store Configuration
+
+```typescript
+const vectorStore = new AzureAISearchVectorStore({
+  credential: new DefaultAzureCredential(),
+  indexName: "llamaindex-vector-store-example",
+  indexManagement: IndexManagement.CREATE_IF_NOT_EXISTS,
+  embeddingDimensionality: 3072,
+  vectorAlgorithmType: KnownVectorSearchAlgorithmKind.ExhaustiveKnn,
+  languageAnalyzer: KnownAnalyzerNames.EnLucene,
+  filterableMetadataFieldKeys: metadataFields,
+});
+```
+
+### Index Management Options
+
+- `IndexManagement.VALIDATE_INDEX` - Validates existing index, throws error if missing
+- `IndexManagement.NO_VALIDATION` - Attempts to access index, throws error if missing
+- `IndexManagement.CREATE_IF_NOT_EXISTS` - Creates index if it doesn't exist (recommended)
+
+## Search Modes
+
+The example demonstrates three search modes:
+
+1. **Vector Search (DEFAULT)** - Pure semantic vector similarity
+2. **Hybrid Search** - Combines vector and keyword search
+3. **Semantic Hybrid Search** - Hybrid search with semantic reranking
+
+```typescript
+const response = await queryEngine.retrieve({
+  query: "What is the meaning of life?",
+  mode: VectorStoreQueryMode.HYBRID,
+});
+```
+
+## Document Operations
+
+### Loading Documents
+
+```typescript
+const documents = await new SimpleDirectoryReader().loadData(
+  "data/paul_graham/",
+);
+const index = await VectorStoreIndex.fromDocuments(documents, {
+  storageContext,
+  docStoreStrategy: DocStoreStrategy.UPSERTS,
+});
+```
+
+### Inserting New Documents
+
+```typescript
+await index.insert(
+  new Document({
+    text: "The sky is indigo today.",
+  }),
+);
+```
+
+### Basic Vector Store Operations
+
+```typescript
+// Add documents directly to vector store
+const ids = await vectorStore.add([document]);
+
+// Retrieve nodes by IDs
+const nodes = await vectorStore.getNodes(ids);
+
+// Delete documents
+await vectorStore.delete(ids[0]);
+```
+
+## Metadata Filtering
+
+The example includes metadata field definitions for filtering:
+
+```typescript
+const metadataFields = {
+  author: "author",
+  theme: ["theme", MetadataIndexFieldType.STRING],
+  director: "director",
+};
+```
+
+**Known Issue**: Metadata filtering currently has limitations and may throw errors like:
+
+```
+RestError: Invalid expression: Could not find a property named 'theme' on type 'search.document'.
+```
+
+## Running the Example
+
+```bash
+# Install dependencies
+npm install
+
+# Set up environment variables in .env file
+# Run the example
+npm start
+```
+
+## Sample Data
+
+The example uses Paul Graham's essay "What I Worked On" located in `data/paul_graham/paul_graham_essay.txt` for demonstration purposes.
+
+## Prerequisites
+
+- Azure AI Search service with proper permissions
+- Azure OpenAI resource with deployed models:
+  - GPT-4 (or similar) for chat completion
+  - text-embedding-ada-002 (or similar) for embeddings
+- Azure AD authentication configured or API keys available
+
+## Key Learnings
+
+1. **Authentication**: Azure AD credentials provide more secure access than API keys
+2. **Index Management**: `CREATE_IF_NOT_EXISTS` is the safest option for development
+3. **Search Modes**: Hybrid search often provides better results than pure vector search
+4. **Embedding Dimensionality**: Must match your embedding model (3072 for ada-002)
+5. **Metadata Filtering**: Currently has limitations that may require workarounds
+
+## Architecture
+
+This example follows the standard LlamaIndex.TS pattern:
+
+1. **Data Ingestion**: SimpleDirectoryReader → Documents
+2. **Processing**: Documents → TextNodes → Embeddings
+3. **Storage**: Vector Store (Azure AI Search)
+4. **Querying**: QueryEngine → Retrieval → Response
+
+The Azure integration provides enterprise-grade scalability and security through Azure's managed services.

examples/storage/elastic-search/CLAUDE.md

@@ -0,0 +1,144 @@
+# CLAUDE.md - Elasticsearch Vector Store Example
+
+This example demonstrates how to use Elasticsearch as a vector store with LlamaIndex.TS for semantic search and retrieval-augmented generation (RAG).
+
+## Overview
+
+This example shows how to:
+
+- Configure Elasticsearch as a vector store using `@llamaindex/elastic-search`
+- Use Google Gemini models for embeddings and text generation
+- Store document embeddings in Elasticsearch
+- Perform semantic queries against the vector store
+
+## Prerequisites
+
+### Elasticsearch Setup
+
+You need access to an Elasticsearch cluster with vector search capabilities:
+
+1. **Elasticsearch Cloud**: Create an account at [elastic.co](https://cloud.elastic.co)
+2. **Self-hosted**: Run Elasticsearch 8.0+ with vector search features enabled
+
+### Environment Variables
+
+Set the required environment variables:
+
+```bash
+export ES_CLOUD_ID="your-elasticsearch-cloud-id"    # For Elasticsearch Cloud
+export ES_API_KEY="your-elasticsearch-api-key"      # API key for authentication
+export GOOGLE_API_KEY="your-google-api-key"         # For Gemini models
+```
+
+For self-hosted Elasticsearch, you can also use:
+
+```bash
+export ES_URL="https://localhost:9200"              # Elasticsearch URL
+export ES_USERNAME="elastic"                        # Username
+export ES_PASSWORD="your-password"                  # Password
+```
+
+## Running the Example
+
+```bash
+# Install dependencies (from project root)
+pnpm install
+
+# Run the example
+npm start
+# or
+npx tsx index.ts
+```
+
+## Code Breakdown
+
+### 1. Model Configuration
+
+The example uses Google Gemini models:
+
+- **Embedding Model**: `TEXT_EMBEDDING_004` for converting text to vector embeddings
+- **LLM**: `GEMINI_PRO_1_5_FLASH` for text generation and query responses
+
+### 2. Vector Store Initialization
+
+```typescript
+const vectorStore = new ElasticSearchVectorStore({
+  indexName: "llamaindex-demo",
+  esCloudId: process.env.ES_CLOUD_ID,
+  esApiKey: process.env.ES_API_KEY,
+});
+```
+
+### 3. Document Indexing
+
+Sample documents are created with metadata and indexed into Elasticsearch:
+
+- Text content is automatically converted to embeddings
+- Metadata (source, author) is stored for filtering and retrieval
+
+### 4. Semantic Querying
+
+The example performs a semantic search query: "What is vector search?" which will find relevant documents based on semantic similarity rather than keyword matching.
+
+## Key Features Demonstrated
+
+- **Vector Storage**: Documents are converted to embeddings and stored in Elasticsearch
+- **Metadata Support**: Documents include metadata for enhanced retrieval
+- **Semantic Search**: Queries use vector similarity rather than keyword matching
+- **RAG Pipeline**: Retrieved documents are used to generate contextual responses
+
+## Elasticsearch Configuration Options
+
+The `ElasticSearchVectorStore` supports various configuration options:
+
+```typescript
+const vectorStore = new ElasticSearchVectorStore({
+  indexName: "my-index", // Elasticsearch index name
+  esCloudId: "cloud-id", // For Elasticsearch Cloud
+  esApiKey: "api-key", // API key authentication
+  // Alternative for self-hosted:
+  // esUrl: "https://localhost:9200",
+  // esUsername: "elastic",
+  // esPassword: "password",
+
+  // Optional settings:
+  similarity: "cosine", // Vector similarity metric
+  vectorField: "embedding", // Field name for vectors
+  textField: "text", // Field name for text content
+});
+```
+
+## Index Management
+
+The vector store will automatically:
+
+- Create the Elasticsearch index if it doesn't exist
+- Configure appropriate mappings for vector and text fields
+- Handle document insertion and retrieval
+
+## Advanced Usage
+
+For production usage, consider:
+
+1. **Index Templates**: Define custom Elasticsearch index templates for specific mapping requirements
+2. **Filtering**: Use metadata filters to restrict search scope
+3. **Hybrid Search**: Combine vector search with traditional keyword search
+4. **Batch Operations**: Use bulk indexing for large document collections
+5. **Index Lifecycle**: Implement proper index rotation and cleanup strategies
+
+## Troubleshooting
+
+Common issues and solutions:
+
+1. **Connection Errors**: Verify Elasticsearch credentials and network connectivity
+2. **Index Creation**: Ensure proper permissions for index creation and management
+3. **Vector Dimensions**: Verify embedding model output dimensions match Elasticsearch mapping
+4. **Memory Usage**: Monitor Elasticsearch cluster resources for large vector datasets
+
+## Related Examples
+
+See other storage examples in the parent directory:
+
+- `../pinecone-vector-store/` - Pinecone vector store integration
+- `../chromadb/` - ChromaDB vector store example
+- `../qdrantdb/` - Qdrant vector store example

examples/storage/pg/CLAUDE.md

@@ -0,0 +1,226 @@
+# CLAUDE.md - PostgreSQL Vector Store Examples
+
+This directory demonstrates PostgreSQL vector storage integration with LlamaIndex.TS using the `@llamaindex/postgres` package and pgvector extension for similarity search and RAG applications.
+
+## Overview
+
+These examples showcase how to use PostgreSQL as a vector database for storing document embeddings and performing semantic search. The package includes examples for self-hosted PostgreSQL, cloud providers (Supabase, Vercel, Neon), and both document loading and querying workflows.
+
+## File Structure
+
+### Core Examples
+
+- **`load-docs.ts`** - Document ingestion pipeline that reads files, generates embeddings, and stores them in PostgreSQL
+- **`query.ts`** - Interactive RAG query interface with readline input for asking questions against stored embeddings
+- **`pg-reader.ts`** - Demonstrates reading documents back from PostgreSQL using SimplePostgresReader
+
+### Provider-Specific Examples
+
+- **`supabase.ts`** - Supabase PostgreSQL integration with `POSTGRES_URL` connection string
+- **`vercel.ts`** - Vercel Postgres integration using `@vercel/postgres` SDK
+- **`neon.ts`** - Neon PostgreSQL integration with SSL configuration and endpoint options
+
+## Prerequisites
+
+### Database Setup
+
+All examples require a PostgreSQL instance with the pgvector extension:
+
+**Local Docker Instance:**
+
+```bash
+docker run -d --rm --name vector-db -p 5432:5432 -e "POSTGRES_HOST_AUTH_METHOD=trust" ankane/pgvector
+```
+
+**Cloud Alternatives:**
+
+- Supabase: Managed PostgreSQL with built-in pgvector support
+- Vercel Postgres: Serverless PostgreSQL for Vercel deployments
+- Neon: Serverless PostgreSQL with branching capabilities
+- Timescale: Time-series focused PostgreSQL service
+
+### Environment Variables
+
+```bash
+# Standard PostgreSQL connection (used by load-docs.ts, query.ts, pg-reader.ts)
+export PGHOST=localhost
+export PGUSER=postgres
+export PGPASSWORD=postgres
+export PGDATABASE=test
+export PGPORT=5432
+export PG_CONNECTION_STRING="postgresql://user:password@host:port/database"
+
+# Provider-specific connections
+export POSTGRES_URL="postgresql://..." # Supabase
+export POSTGRES_URL="postgres://..."   # Vercel
+export ENDPOINT_ID="your-neon-endpoint" # Neon
+
+# Required for embeddings
+export OPENAI_API_KEY="sk-..."
+```
+
+## Running Examples
+
+### Document Loading and RAG Workflow
+
+```bash
+# Load documents from a directory
+npx tsx load-docs.ts ../data
+
+# Query the loaded documents interactively
+npx tsx query.ts
+```
+
+### Provider-Specific Examples
+
+```bash
+# Supabase example
+npx tsx supabase.ts
+
+# Vercel Postgres example
+npx tsx vercel.ts
+
+# Neon example
+npx tsx neon.ts
+
+# PostgreSQL reader example
+npx tsx pg-reader.ts
+```
+
+## Key Components
+
+### PGVectorStore Configuration
+
+The examples demonstrate various `PGVectorStore` initialization patterns:
+
+**Connection String (load-docs.ts, query.ts):**
+
+```typescript
+const pgvs = new PGVectorStore({
+  clientConfig: {
+    connectionString: process.env.PG_CONNECTION_STRING,
+  },
+});
+```
+
+**Direct Client (neon.ts, vercel.ts):**
+
+```typescript
+const vectorStore = new PGVectorStore({
+  dimensions: 3,
+  client: sql, // postgres client instance
+});
+```
+
+**Standard Config (pg-reader.ts):**
+
+```typescript
+const vectorStore = new PGVectorStore({
+  clientConfig: {
+    host: "localhost",
+    port: 5432,
+    database: "test",
+    user: "postgres",
+    password: "postgres",
+  },
+  dimensions: 3,
+  tableName: "llamaindex_vector",
+});
+```
+
+### Document Processing Pipeline
+
+1. **Document Reading**: Uses `SimpleDirectoryReader` to load files from directory
+2. **Embedding Generation**: Automatic embedding creation via OpenAI (configurable)
+3. **Vector Storage**: Embeddings stored in PostgreSQL with metadata
+4. **Index Creation**: `VectorStoreIndex.fromDocuments()` creates searchable index
+5. **Query Engine**: `index.asQueryEngine()` enables RAG queries
+
+### Collections and Data Management
+
+```typescript
+// Set collection name for data organization
+pgvs.setCollection(sourceDir);
+
+// Clear existing data before loading
+await pgvs.clearCollection();
+```
+
+## Usage Patterns
+
+### Full RAG Pipeline (load-docs.ts)
+
+```typescript
+// Load documents
+const docs = await rdr.loadData({ directoryPath: sourceDir });
+
+// Create vector store with collection
+const pgvs = new PGVectorStore({ clientConfig });
+pgvs.setCollection(sourceDir);
+await pgvs.clearCollection();
+
+// Build index and store embeddings
+const ctx = await storageContextFromDefaults({ vectorStore: pgvs });
+const index = await VectorStoreIndex.fromDocuments(docs, {
+  storageContext: ctx,
+});
+```
+
+### Interactive Querying (query.ts)
+
+```typescript
+// Load existing vector store
+const index = await VectorStoreIndex.fromVectorStore(pgvs);
+const queryEngine = await index.asQueryEngine();
+
+// Interactive Q&A loop
+const answer = await queryEngine.query({ query: question });
+console.log(answer.response);
+```
+
+### Direct Vector Operations (neon.ts, vercel.ts)
+
+```typescript
+// Add documents with pre-computed embeddings
+await vectorStore.add([
+  new Document({
+    text: "hello, world",
+    embedding: [1, 2, 3],
+  }),
+]);
+
+// Direct similarity search
+const results = await vectorStore.query({
+  mode: VectorStoreQueryMode.DEFAULT,
+  similarityTopK: 1,
+  queryEmbedding: [1, 2, 3],
+});
+```
+
+## Error Handling
+
+All examples include error handling for common issues:
+
+- Missing environment variables
+- Database connection failures
+- Invalid embeddings or documents
+- Provider-specific authentication errors
+
+## Dependencies
+
+Key packages used across examples:
+
+- `@llamaindex/postgres` - PostgreSQL vector store implementation
+- `@llamaindex/readers/directory` - File system document reader
+- `@llamaindex/openai` - OpenAI embeddings (implicit via Settings)
+- `llamaindex` - Core LlamaIndex functionality
+- Provider-specific SDKs: `@vercel/postgres`, `postgres` (for Neon)
+
+## Integration Notes
+
+- **pgvector Extension**: Required for vector similarity operations
+- **SSL Configuration**: Properly configured for cloud providers (Neon, Supabase)
+- **Connection Pooling**: Handled automatically by underlying client libraries
+- **Schema Management**: Vector store creates tables automatically
+- **Metadata Support**: Full metadata storage and retrieval capabilities
+- **Multi-tenancy**: Collection-based data organization support

examples/storage/supabase/CLAUDE.md

@@ -0,0 +1,136 @@
+# CLAUDE.md - Supabase Vector Store Example
+
+This example demonstrates how to use Supabase as a vector store with LlamaIndex.TS for semantic search and retrieval-augmented generation (RAG).
+
+## Overview
+
+This example shows:
+
+- Setting up SupabaseVectorStore with environment configuration
+- Using Google Gemini models for embeddings and LLM operations
+- Creating documents with metadata for storage and retrieval
+- Building a VectorStoreIndex backed by Supabase
+- Performing semantic queries against the stored documents
+
+## Prerequisites
+
+### Environment Variables
+
+Set the following environment variables before running:
+
+```bash
+export SUPABASE_URL="your-supabase-project-url"
+export SUPABASE_KEY="your-supabase-anon-key"
+export GOOGLE_API_KEY="your-google-api-key"  # For Gemini models
+```
+
+### Supabase Setup
+
+1. Create a Supabase project at https://supabase.com
+2. Enable the vector extension in your database
+3. Create a table for document storage (the example uses table name "document")
+4. Obtain your project URL and anon key from the project settings
+
+## Running the Example
+
+```bash
+# Install dependencies (from project root)
+pnpm install
+
+# Run the example
+npm start
+# or
+npx tsx index.ts
+```
+
+## Code Structure
+
+### Key Components
+
+**Vector Store Configuration:**
+
+- Uses `SupabaseVectorStore` from `@llamaindex/supabase`
+- Configured with project URL, API key, and table name
+- Supports document deletion and management
+
+**Model Setup:**
+
+- **Embeddings**: Google Gemini TEXT_EMBEDDING_004 model
+- **LLM**: Google Gemini Pro 1.5 Flash model
+- Configured through `Settings.embedModel` and `Settings.llm`
+
+**Document Processing:**
+
+- Creates sample documents with text content and metadata
+- Metadata includes source and author information for filtering
+- Documents are processed into embeddings and stored in Supabase
+
+**Query Engine:**
+
+- Builds VectorStoreIndex from documents using Supabase storage
+- Creates query engine for semantic search
+- Supports natural language queries with vector similarity search
+
+## Features Demonstrated
+
+### Vector Storage
+
+- Document ingestion with automatic embedding generation
+- Metadata preservation for filtering and context
+- Persistent storage in Supabase PostgreSQL with vector extension
+
+### Semantic Search
+
+- Natural language query processing
+- Vector similarity search for relevant document retrieval
+- Context-aware response generation using retrieved documents
+
+### Storage Management
+
+- Document deletion capabilities (shown in commented code)
+- Configurable table names for organization
+- Integration with Supabase's scalable infrastructure
+
+## Dependencies
+
+- `@llamaindex/supabase` - Supabase vector store integration
+- `@llamaindex/google` - Google Gemini models for embeddings and LLM
+- `llamaindex` - Core LlamaIndex functionality
+- Supabase project with vector extension enabled
+
+## Usage Notes
+
+1. **Database Setup**: Ensure your Supabase database has the vector extension enabled
+2. **Table Configuration**: The example uses table name "document" - modify as needed
+3. **API Costs**: Running this example will consume Google API credits for embeddings and LLM calls
+4. **Storage Persistence**: Documents remain in Supabase between runs unless explicitly deleted
+5. **Scaling**: Supabase vector store scales automatically with your database plan
+
+## Common Patterns
+
+### Custom Table Configuration
+
+```typescript
+const vectorStore = new SupabaseVectorStore({
+  supabaseUrl: process.env.SUPABASE_URL,
+  supabaseKey: process.env.SUPABASE_KEY,
+  table: "custom_table_name",
+});
+```
+
+### Document Management
+
+```typescript
+// Delete specific document by ID
+await vectorStore.delete("document-uuid");
+
+// Query with metadata filtering
+const response = await queryEngine.query({
+  query: "search query",
+  // Additional filtering can be implemented
+});
+```
+
+### Error Handling
+
+Always include proper validation for required environment variables and handle Supabase connection errors appropriately.

packages/autotool/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @llamaindex/autotool
 
+## 8.0.5
+
+### Patch Changes
+
+- llamaindex@0.11.5
+
+## 8.0.4
+
+### Patch Changes
+
+- llamaindex@0.11.4
+
 ## 8.0.3
 
 ### Patch Changes

packages/autotool/CLAUDE.md

@@ -0,0 +1,95 @@
+# @llamaindex/autotool
+
+Auto-transpilation system that converts regular JavaScript/TypeScript functions into LLM-compatible tools for use with LlamaIndex agents.
+
+## Architecture
+
+The autotool package provides a build-time transformation system that automatically generates tool metadata from TypeScript function signatures and JSDoc comments. It works by:
+
+1. **Detection**: Identifies tool files through `.tool.ts/.js` extensions or `"use tool"` directive
+2. **Analysis**: Uses TypeDoc to parse TypeScript declarations and extract function signatures, parameters, and documentation
+3. **Transformation**: Injects metadata and runtime registration code into the source
+4. **Runtime**: Provides conversion utilities to generate OpenAI or LlamaIndex compatible tool definitions
+
+## Core Components
+
+### Compiler (`src/compiler.ts`)
+
+- `transformAutoTool()`: Main transformation function that parses TypeScript with TypeDoc
+- `isToolFile()`: Detects `.tool.[jt]sx?` file extensions
+- `isJSorTS()`: Matches JavaScript/TypeScript file patterns
+- Generates JSON Schema from TypeScript parameter types
+- Extracts function descriptions from JSDoc comments
+
+### Runtime System (`src/index.ts`)
+
+- `injectMetadata()`: Injected by compiler to register tool metadata at runtime
+- `convertTools()`: Converts stored metadata to OpenAI (`ChatCompletionTool[]`) or LlamaIndex (`BaseToolWithCall[]`) formats
+- `callTool()`: Direct tool invocation by name with parameter mapping
+- Uses Jotai atoms for state management of tool registry
+
+### Build Integration
+
+- **Next.js**: `src/next.ts` - Webpack plugin integration via `withNext()`
+- **Vite**: `src/vite.ts` - Vite plugin wrapper
+- **Webpack**: `src/webpack.ts` - Direct webpack plugin
+- **Node.js**: `src/node.ts` + `src/loader.ts` - Module loader hooks for runtime transformation
+- **Universal**: `src/plugin.ts` - Unplugin factory for cross-bundler support
+
+## Usage Patterns
+
+### File-based Detection
+
+```typescript
+// weather.tool.ts
+export function getWeather(city: string) {
+  // Implementation
+}
+```
+
+### Directive-based Detection
+
+```typescript
+"use tool";
+
+export function getWeather(city: string) {
+  // Implementation
+}
+```
+
+### Runtime Integration
+
+```typescript
+import { convertTools } from "@llamaindex/autotool";
+
+// For OpenAI format
+const openaiTools = convertTools("openai");
+
+// For LlamaIndex format
+const llamaindexTools = convertTools("llamaindex");
+```
+
+## Key Features
+
+- **Zero-config**: Automatic tool detection and metadata generation
+- **Type-safe**: Leverages TypeScript for parameter validation and schema generation
+- **Multi-format**: Supports both OpenAI and LlamaIndex tool formats
+- **Build-time**: No runtime overhead for metadata generation
+- **Cross-platform**: Works with Node.js, Next.js, Vite, and Webpack
+- **JSDoc integration**: Extracts descriptions from TypeScript comments
+
+## Dependencies
+
+- `@swc/core`: Fast TypeScript/JavaScript parsing
+- `typedoc`: TypeScript documentation generation for metadata extraction
+- `unplugin`: Universal plugin system for build tool integration
+- `jotai`: Atomic state management for tool registry
+
+## Development Commands
+
+- `pnpm build` - Build using bunchee
+- `pnpm dev` - Watch mode development
+
+## Examples
+
+See `examples/01_node/` for a complete Node.js usage example with tool files and integration.

packages/autotool/examples/01_node/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @llamaindex/autotool-01-node-example
 
+## 0.0.113
+
+### Patch Changes
+
+- llamaindex@0.11.5
+- @llamaindex/autotool@8.0.5
+
+## 0.0.112
+
+### Patch Changes
+
+- llamaindex@0.11.4
+- @llamaindex/autotool@8.0.4
+
 ## 0.0.111
 
 ### Patch Changes

packages/autotool/examples/01_node/CLAUDE.md

@@ -0,0 +1,80 @@
+# @llamaindex/autotool Node.js Example
+
+This example demonstrates how to use the `@llamaindex/autotool` package in a Node.js environment to automatically convert TypeScript functions into LLM-compatible tools.
+
+## What This Example Shows
+
+This example showcases the core autotool functionality:
+
+1. **Automatic Tool Detection**: Functions in `.tool.ts` files are automatically detected and converted to LLM tools
+2. **TypeScript Integration**: Function signatures and JSDoc comments are used to generate tool metadata
+3. **OpenAI Compatibility**: Tools are converted to OpenAI's function calling format
+4. **Runtime Registration**: Tools are automatically registered and made available at runtime
+
+## Architecture
+
+### Key Files
+
+- `src/index.ts` - Main application that uses the auto-generated tools with OpenAI
+- `src/index.tool.ts` - Tool definitions that get auto-transpiled (exports `getCurrentLocation` and `getWeather`)
+- `src/utils.ts` - Utility functions with JSDoc documentation
+- `package.json` - Configuration with Node.js loader setup
+
+### How It Works
+
+1. **Tool Detection**: The `.tool.ts` file extension triggers autotool processing
+2. **Metadata Generation**: TypeScript signatures and JSDoc comments are analyzed to create tool schemas
+3. **Runtime Loading**: The Node.js loader (`@llamaindex/autotool/node`) processes files at import time
+4. **Tool Conversion**: `convertTools("openai")` generates OpenAI-compatible tool definitions
+5. **LLM Integration**: Tools are passed to OpenAI's chat completion API
+
+## Usage
+
+### Running the Example
+
+```bash
+pnpm start
+```
+
+This runs: `node --import tsx --import @llamaindex/autotool/node ./src/index.ts`
+
+### Key Components
+
+**Node.js Loader Setup** (package.json):
+
+```json
+{
+  "scripts": {
+    "start": "node --import tsx --import @llamaindex/autotool/node ./src/index.ts"
+  }
+}
+```
+
+**Tool File** (src/index.tool.ts):
+
+- Functions exported from `.tool.ts` files are automatically converted to tools
+- JSDoc comments become tool descriptions
+- TypeScript types generate JSON schemas for parameters
+
+**Main Application** (src/index.ts):
+
+- Imports the tool file to trigger registration
+- Uses `convertTools("openai")` to get OpenAI-compatible tool definitions
+- Passes tools to OpenAI chat completion
+
+## Dependencies
+
+- `@llamaindex/autotool` - Core autotool functionality
+- `llamaindex` - LlamaIndex TypeScript framework
+- `openai` - OpenAI API client
+- `tsx` - TypeScript execution for Node.js
+
+## Development Notes
+
+- The `--import` flags in the start script enable both TypeScript execution (tsx) and autotool processing
+- Tool files must use `.tool.ts` extension or contain `"use tool"` directive
+- JSDoc comments on exported functions become tool descriptions
+- TypeScript parameter types are automatically converted to JSON Schema
+- The example demonstrates OpenAI format, but `convertTools("llamaindex")` is also available
+
+This example serves as a minimal working demonstration of autotool's core functionality in a Node.js environment.

packages/autotool/examples/01_node/package.json

@@ -13,5 +13,5 @@
   "scripts": {
     "start": "node --import tsx --import @llamaindex/autotool/node ./src/index.ts"
   },
-  "version": "0.0.111"
+  "version": "0.0.113"
 }

packages/autotool/package.json

@@ -6,7 +6,7 @@
     "url": "git+https://github.com/run-llama/LlamaIndexTS.git",
     "directory": "packages/autotool"
   },
-  "version": "8.0.3",
+  "version": "8.0.5",
   "description": "auto transpile your JS function to LLM Agent compatible",
   "files": [
     "dist",

packages/cloud/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @llamaindex/cloud
 
+## 4.0.13
+
+### Patch Changes
+
+- Updated dependencies [71598f8]
+  - @llamaindex/core@0.6.9
+
+## 4.0.12
+
+### Patch Changes
+
+- Updated dependencies [c927457]
+  - @llamaindex/core@0.6.8
+
 ## 4.0.11
 
 ### Patch Changes

packages/cloud/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llamaindex/cloud",
-  "version": "4.0.11",
+  "version": "4.0.13",
   "type": "module",
   "license": "MIT",
   "scripts": {

packages/core/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @llamaindex/core
 
+## 0.6.9
+
+### Patch Changes
+
+- 71598f8: Added interrupted, generationComplete and turnComplete event support in the live api
+
+## 0.6.8
+
+### Patch Changes
+
+- c927457: Use base64 for encoding files
+
 ## 0.6.7
 
 ### Patch Changes

packages/core/CLAUDE.md

@@ -0,0 +1,121 @@
+# CLAUDE.md - @llamaindex/core
+
+This file provides guidance to Claude Code when working with the `@llamaindex/core` package.
+
+## Package Overview
+
+The `@llamaindex/core` package contains the foundational abstract base classes and interfaces for the LlamaIndex.TS framework. This package provides runtime-agnostic core functionality that is implemented by provider-specific packages.
+
+## Development Commands
+
+From this package directory:
+
+- `pnpm dev` - Start development mode with file watching using bunchee
+- `pnpm build` - Build the package using bunchee
+- `pnpm test` - Run unit tests (after building)
+
+From the workspace root:
+
+- `turbo run build --filter="@llamaindex/core"` - Build only this package
+- `turbo run test --filter="@llamaindex/core"` - Test only this package
+
+## Architecture
+
+### Modular Export System
+
+This package uses a sophisticated modular export system where functionality is organized into sub-modules that can be imported independently:
+
+```typescript
+import { BaseLLM } from "@llamaindex/core/llms";
+import { BaseEmbedding } from "@llamaindex/core/embeddings";
+import { BaseNode } from "@llamaindex/core/schema";
+import { Settings } from "@llamaindex/core/global";
+```
+
+### Package Structure
+
+**Core Modules:**
+
+- `src/llms/` - Abstract LLM base classes and interfaces (`BaseLLM`, `LLM` interface)
+- `src/embeddings/` - Abstract embedding base classes (`BaseEmbedding`)
+- `src/schema/` - Core data structures (`BaseNode`, `Document`, output parsers)
+- `src/global/` - Global settings and configuration management
+- `src/node-parser/` - Text chunking and parsing abstractions
+- `src/query-engine/` - Query processing abstractions
+- `src/chat-engine/` - Conversational interface abstractions
+- `src/memory/` - Chat memory management
+- `src/prompts/` - Prompt template system
+- `src/response-synthesizers/` - Response generation abstractions
+- `src/retriever/` - Document retrieval abstractions
+- `src/vector-store/` - Vector store abstractions
+- `src/storage/` - Data persistence abstractions (chat, doc, index, kv stores)
+- `src/tools/` - Turning functions into tools that can be used by LLMs
+- `src/utils/` - Shared utilities
+- `src/decorator/` - Event handling and lazy initialization
+- `src/postprocessor/` - Result post-processing
+- `src/data-structs/` - Data structure utilities
+- `src/indices/` - Index abstractions
+
+**Deprecated Modules:**
+
+- `src/agent/` - Legacy agent implementations (use `@llamaindex/workflow` instead)
+
+### Key Design Patterns
+
+**Abstract Base Classes:** All core functionality is defined as abstract classes that provider packages extend. For example:
+
+- `BaseLLM` - Extended by OpenAI, Anthropic, etc.
+- `BaseEmbedding` - Extended by embedding providers
+- `BaseVectorStore` - Extended by Pinecone, Chroma, etc.
+
+**Runtime Agnostic:** Core functionality works across Node.js, Deno, Bun, and edge runtimes through the `@llamaindex/env` compatibility layer.
+
+**Settings Management:** Global configuration through the `Settings` object allows dynamic swapping of LLMs, embeddings, and other components.
+
+**Transform Components:** Many components extend `TransformComponent` for composable data processing pipelines.
+
+## Build System
+
+- Uses **bunchee** for building with dual CJS/ESM support
+- Each subdirectory becomes a separate entry point in package.json exports
+- Build outputs go to `{module}/dist/` directories
+- TypeScript types are generated alongside JavaScript
+
+## Testing
+
+- Tests are located in `tests/` directory
+- Tests depend on build artifacts - always run `pnpm build` before testing
+- Use `vitest` as the test runner
+
+## Key Dependencies
+
+- `@llamaindex/env` - Runtime environment abstractions
+- `zod` - Schema validation and type safety
+- `magic-bytes.js` - File type detection
+- `@types/node` - Node.js type definitions
+
+## Development Guidelines
+
+**When extending core classes:**
+
+1. Import from the appropriate sub-module (e.g., `@llamaindex/core/llms`)
+2. Implement all abstract methods
+3. Follow the existing patterns for error handling and async operations
+4. Consider runtime compatibility when using Node.js-specific APIs
+
+**When modifying core interfaces:**
+
+1. Ensure backward compatibility
+2. Update both the interface and abstract base class
+3. Consider impact on all provider packages
+4. Test across multiple runtimes
+
+**File Organization:**
+
+- Each module should have an `index.ts` that exports public APIs
+- Keep internal implementation details private
+- Use consistent naming conventions (e.g., `BaseFoo` for abstract classes)
+
+## Module Dependencies
+
+This package has minimal external dependencies to ensure broad compatibility. The main dependency is `@llamaindex/env` which provides runtime-specific implementations for file system, fetch, and other platform-specific APIs.

packages/core/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@llamaindex/core",
   "type": "module",
-  "version": "0.6.7",
+  "version": "0.6.9",
   "description": "LlamaIndex Core Module",
   "exports": {
     "./agent": {

packages/core/src/llms/live.ts

@@ -17,13 +17,23 @@ export type CloseEvent = { type: "close" };
 
 export type SetupCompleteEvent = { type: "setupComplete" };
 
+// a client message has interrupted current model generation
+export type InterruptedEvent = { type: "interrupted" };
+
+export type GenerationCompleteEvent = { type: "generationComplete" };
+
+export type TurnCompleteEvent = { type: "turnComplete" };
+
 export type LiveEvent =
   | OpenEvent
   | AudioEvent
   | TextEvent
   | ErrorEvent
   | CloseEvent
-  | SetupCompleteEvent;
+  | SetupCompleteEvent
+  | InterruptedEvent
+  | GenerationCompleteEvent
+  | TurnCompleteEvent;
 
 export const liveEvents = {
   open: { include: (e: LiveEvent): e is OpenEvent => e.type === "open" },
@@ -41,8 +51,18 @@ export const liveEvents = {
     include: (e: LiveEvent): e is SetupCompleteEvent =>
       e.type === "setupComplete",
   },
+  interrupted: {
+    include: (e: LiveEvent): e is InterruptedEvent => e.type === "interrupted",
+  },
+  generationComplete: {
+    include: (e: LiveEvent): e is GenerationCompleteEvent =>
+      e.type === "generationComplete",
+  },
+  turnComplete: {
+    include: (e: LiveEvent): e is TurnCompleteEvent =>
+      e.type === "turnComplete",
+  },
 };
-
 export abstract class LiveLLMSession {
   protected eventQueue: LiveEvent[] = [];
   protected eventResolvers: ((value: LiveEvent) => void)[] = [];

packages/core/src/llms/type.ts

@@ -166,28 +166,29 @@ export type MessageContentImageDetail = {
 
 export type MessageContentAudioDetail = {
   type: "audio";
-  //audio could be a base64 string as well
-  data: string | Uint8Array;
+  // this is a base64 encoded string
+  data: string;
   mimeType: string;
 };
 
 export type MessageContentVideoDetail = {
   type: "video";
-  //video could be a base64 string as well
-  data: string | Uint8Array;
+  // this is a base64 encoded string
+  data: string;
   mimeType: string;
 };
 
 export type MessageContentImageDataDetail = {
   type: "image";
-  //image could be a base64 string as well
-  data: string | Uint8Array;
+  // this is a base64 encoded string
+  data: string;
   mimeType: string;
 };
 
 export type MessageContentFileDetail = {
   type: "file";
-  data: Uint8Array;
+  // this is a base64 encoded string
+  data: string;
   mimeType: string;
 };
 

packages/env/CLAUDE.md

@@ -0,0 +1,129 @@
+# @llamaindex/env Package
+
+This package provides environment-specific compatibility layers for different JavaScript runtimes. It's a critical component that enables LlamaIndex.TS to work across Node.js, Deno, Bun, browser, Vercel Edge Runtime, and Cloudflare Workers.
+
+## Package Overview
+
+**Purpose**: Environment wrapper that provides unified APIs across all supported JavaScript runtimes
+**Main exports**:
+
+- `.` - Main environment APIs
+- `./tokenizers` - Tokenization utilities
+- `./multi-model` - Multi-modal model support
+
+## Development Commands
+
+**Build and test this package:**
+
+- `pnpm build` - Build the package using bunchee
+- `pnpm dev` - Build in watch mode
+- `pnpm test` - Run tests with vitest
+
+**From workspace root:**
+
+- `turbo run build --filter="@llamaindex/env"` - Build this specific package
+- `turbo run test --filter="@llamaindex/env"` - Test this specific package
+
+## Runtime Support
+
+The package uses conditional exports to provide runtime-specific implementations:
+
+### Node.js Environment (`index.ts`)
+
+- Full Node.js built-in modules (fs, crypto, streams, etc.)
+- AsyncLocalStorage for context management
+- Native filesystem operations
+- Crypto utilities (createHash, randomUUID)
+
+### Browser Environment (`index.browser.ts`)
+
+- Web polyfills for browser compatibility
+- Limited to browser-safe APIs
+- Web-compatible base64 utilities
+
+### Cloudflare Workers (`index.workerd.ts`)
+
+- Minimal polyfills for Workers environment
+- Environment variable access via `INTERNAL_ENV`
+- No filesystem access
+
+### Vercel Edge Runtime (`index.edge-light.ts`)
+
+- Edge-compatible polyfills
+- Non-Node.js AsyncLocalStorage implementation
+
+## Key Components
+
+### Async Local Storage (`src/als/`)
+
+- `index.node.ts` - Native Node.js AsyncLocalStorage
+- `index.non-node.ts` - Polyfill for non-Node environments
+- `index.web.ts` - Web-compatible implementation
+- `index.workerd.ts` - Cloudflare Workers implementation
+
+### File System (`src/fs/`)
+
+- `node.ts` - Node.js fs module wrapper
+- `memory.ts` - In-memory filesystem for testing
+- `memfs/` - Memory filesystem implementation
+
+### Tokenizers (`src/internal/tokenizers/`)
+
+- Runtime-specific tokenizer implementations
+- Supports both `gpt-tokenizer` (fast) and `js-tiktoken` (fallback)
+- Encoding/decoding for token counting
+
+### Multi-Model Support (`src/internal/multi-model/`)
+
+- Hugging Face Transformers integration
+- Runtime-specific loading strategies
+- Browser, Node.js, and non-Node implementations
+
+### Utilities (`src/utils/`)
+
+- `base64.ts` - Base64 encoding/decoding utilities
+- `shared.ts` - Shared utility classes
+- `index.ts` - Environment detection and configuration
+
+## Architecture Patterns
+
+### Conditional Exports
+
+The package.json uses conditional exports to map different entry points based on runtime:
+
+```json
+"exports": {
+  ".": {
+    "node": "./dist/index.js",
+    "workerd": "./dist/index.workerd.js",
+    "edge-light": "./dist/index.edge-light.js",
+    "browser": "./dist/index.browser.js"
+  }
+}
+```
+
+### Polyfill Strategy
+
+- Each runtime gets only the APIs it can support
+- Graceful degradation for missing functionality
+- Common interface across all environments
+
+### Dependency Management
+
+- Core dependencies: `pathe`, `@aws-crypto/sha256-js`, `js-tiktoken`
+- Optional peer dependencies: `@huggingface/transformers`, `gpt-tokenizer`
+- Runtime detection determines which implementations to use
+
+## Testing
+
+- Tests in `tests/` directory use Vitest
+- `memfs.test.ts` - Memory filesystem tests
+- `tokenizer.test.ts` - Tokenizer functionality tests
+- Always run `pnpm build` before testing as tests depend on build artifacts
+
+## Usage Notes
+
+- This package is typically imported by other LlamaIndex packages, not directly by users
+- Provides the runtime abstraction layer that makes LlamaIndex framework runtime-agnostic
+- When adding new environment-specific functionality, ensure all supported runtimes have appropriate implementations or polyfills
+- Use environment detection utilities to handle runtime differences gracefully

packages/experimental/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @llamaindex/experimental
 
+## 0.0.182
+
+### Patch Changes
+
+- llamaindex@0.11.5
+
+## 0.0.181
+
+### Patch Changes
+
+- llamaindex@0.11.4
+
 ## 0.0.180
 
 ### Patch Changes

packages/experimental/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@llamaindex/experimental",
   "description": "Experimental package for LlamaIndexTS",
-  "version": "0.0.180",
+  "version": "0.0.182",
   "type": "module",
   "types": "dist/type/index.d.ts",
   "main": "dist/cjs/index.js",

packages/llamaindex/CHANGELOG.md

@@ -1,5 +1,26 @@
 # llamaindex
 
+## 0.11.5
+
+### Patch Changes
+
+- Updated dependencies [766054b]
+- Updated dependencies [71598f8]
+  - @llamaindex/workflow@1.1.6
+  - @llamaindex/core@0.6.9
+  - @llamaindex/cloud@4.0.13
+  - @llamaindex/node-parser@2.0.9
+
+## 0.11.4
+
+### Patch Changes
+
+- Updated dependencies [c927457]
+  - @llamaindex/core@0.6.8
+  - @llamaindex/cloud@4.0.12
+  - @llamaindex/node-parser@2.0.8
+  - @llamaindex/workflow@1.1.5
+
 ## 0.11.3
 
 ### Patch Changes

packages/llamaindex/CLAUDE.md

@@ -0,0 +1,77 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Package Overview
+
+This is the main `llamaindex` package - the primary entry point for LlamaIndex.TS that aggregates core functionality from `@llamaindex/core` and other workspace packages. It provides multiple runtime-specific entry points and sub-module exports.
+
+## Development Commands
+
+**Build and Test:**
+
+- `pnpm build` - Build the package using bunchee (creates CJS/ESM dual exports)
+- `pnpm dev` - Build in watch mode for development
+- `pnpm lint` - Run ESLint on source files
+- `cd tests && pnpm test` - Run unit tests (requires build first)
+
+**Testing from workspace root:**
+
+- `turbo run build --filter="llamaindex"` - Build this specific package
+- `turbo run test --filter="llamaindex"` - Test this specific package
+
+## Architecture
+
+### Multi-Runtime Entry Points
+
+The package supports multiple JavaScript runtimes through conditional exports:
+
+- `src/index.ts` - Default Node.js entry point with file system support
+- `src/index.edge.ts` - Edge runtime entry (Vercel Edge, Cloudflare Workers)
+- `src/index.react-server.ts` - React Server Components
+- `src/index.workerd.ts` - Cloudflare Workers specific
+
+### Sub-module Structure
+
+The package exports functionality as sub-modules for tree-shaking:
+
+- `/agent` - Deprecated ReAct agents (use `@llamaindex/workflow` instead)
+- `/cloud` - LlamaCloud integration
+- `/engines` - Chat and query engines
+- `/evaluation` - RAG evaluation metrics
+- `/extractors` - Metadata extraction
+- `/indices` - Vector, summary, and keyword indices
+- `/ingestion` - Document processing pipelines
+- `/objects` - Object index for structured data
+- `/postprocessors` - Result reranking and filtering
+- `/selectors` - LLM-based routing and selection
+- `/storage` - Local storage implementations
+- `/tools` - Function calling tools
+- `/vector-store` - Simple vector store implementation
+- `/next` - Next.js specific utilities
+
+### Core Integration
+
+This package primarily aggregates and re-exports from:
+
+- `@llamaindex/core` - Abstract base classes and interfaces
+- `@llamaindex/cloud` - LlamaCloud services
+- `@llamaindex/env` - Runtime compatibility layers
+- `@llamaindex/node-parser` - Text chunking
+
+### Testing Structure
+
+Tests are in a separate `tests/` subdirectory with its own package.json:
+
+- Tests depend on build artifacts - always build before testing
+- Uses Vitest with setup in `vitest.setup.ts`
+- Test files follow `*.test.ts` pattern
+- Tests import from the built package, not source files
+
+### Development Notes
+
+- Uses bunchee for building with dual CJS/ESM output
+- Build process automatically copies README and LICENSE from workspace root
+- Package supports Node.js >=18.0.0
+- Entry points are configured for tree-shaking and runtime optimization
+- When adding new functionality, consider if it should be a sub-module export

packages/llamaindex/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llamaindex",
-  "version": "0.11.3",
+  "version": "0.11.5",
   "license": "MIT",
   "type": "module",
   "keywords": [
@@ -24,7 +24,7 @@
     "@llamaindex/core": "workspace:*",
     "@llamaindex/env": "workspace:*",
     "@llamaindex/node-parser": "workspace:*",
-    "@llamaindex/workflow": "1.0.3",
+    "@llamaindex/workflow": "1.1.6",
     "@types/lodash": "^4.17.7",
     "@types/node": "^22.9.0",
     "ajv": "^8.17.1",

packages/llamaindex/tests/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @llamaindex/core-test
 
+## 0.1.4
+
+### Patch Changes
+
+- @llamaindex/openai@0.4.3
+
+## 0.1.3
+
+### Patch Changes
+
+- Updated dependencies [c927457]
+  - @llamaindex/openai@0.4.2
+
 ## 0.1.2
 
 ### Patch Changes

packages/llamaindex/tests/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@llamaindex/llamaindex-test",
   "private": true,
-  "version": "0.1.2",
+  "version": "0.1.4",
   "type": "module",
   "scripts": {
     "test": "vitest run"

packages/node-parser/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @llamaindex/node-parser
 
+## 2.0.9
+
+### Patch Changes
+
+- Updated dependencies [71598f8]
+  - @llamaindex/core@0.6.9
+
+## 2.0.8
+
+### Patch Changes
+
+- Updated dependencies [c927457]
+  - @llamaindex/core@0.6.8
+
 ## 2.0.7
 
 ### Patch Changes

packages/node-parser/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llamaindex/node-parser",
-  "version": "2.0.7",
+  "version": "2.0.9",
   "description": "Node parser for LlamaIndex",
   "type": "module",
   "exports": {

packages/providers/anthropic/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @llamaindex/anthropic
 
+## 0.3.11
+
+### Patch Changes
+
+- Updated dependencies [71598f8]
+  - @llamaindex/core@0.6.9
+
+## 0.3.10
+
+### Patch Changes
+
+- c927457: Use base64 for encoding files
+- Updated dependencies [c927457]
+  - @llamaindex/core@0.6.8
+
 ## 0.3.9
 
 ### Patch Changes

packages/providers/anthropic/CLAUDE.md

@@ -0,0 +1,124 @@
+# CLAUDE.md - Anthropic Provider Package
+
+This file provides guidance for working with the `@llamaindex/anthropic` provider package in the LlamaIndex.TS monorepo.
+
+## Package Overview
+
+The `@llamaindex/anthropic` package provides integration with Anthropic's Claude models for LlamaIndex.TS applications. It implements the LlamaIndex provider pattern for seamless integration with the framework's LLM and agent abstractions.
+
+### Key Components
+
+- **`Anthropic` class** (`src/llm.ts`): Main LLM provider implementing `ToolCallLLM` from `@llamaindex/core`
+- **`AnthropicAgent` class** (`src/agent.ts`): Agent implementation extending `LLMAgent` - deprecated
+- **Session management**: Automatic session pooling and reuse for efficient API connections
+
+## Development Commands
+
+Package-specific commands (run from this directory):
+
+- `pnpm test` - Run unit tests using Vitest
+- `pnpm build` - Build the package using bunchee
+- `pnpm dev` - Start development mode with watch
+
+For workspace-wide commands, see the root CLAUDE.md.
+
+## Supported Features
+
+### Models
+
+- **Claude 2.x**: Legacy models (claude-2.0, claude-2.1, claude-instant-1.2)
+- **Claude 3.x**: claude-3-opus, claude-3-sonnet, claude-3-haiku
+- **Claude 3.5.x**: claude-3-5-sonnet, claude-3-5-haiku
+- **Claude 3.7.x**: claude-3-7-sonnet
+- **Claude 4.x**: claude-4-0-sonnet, claude-4-0-opus
+
+For each model, there is a different context window that specifies the maximum number of tokens that can be processed.
+
+### Core Capabilities
+
+- **Tool calling**: Full function calling support (Claude 3+ models only)
+- **Streaming**: Async streaming responses
+- **Multi-modal input**: Text, images (JPEG, PNG, GIF, WebP), and PDF documents
+- **Extended thinking**: Support for Claude's thinking blocks with signature validation
+- **Prompt caching**: Beta support for Anthropic's prompt caching
+- **Message formatting**: Automatic handling of system messages, tool calls, and consecutive message merging
+
+### Configuration Options
+
+- `model`: Model name (defaults to "claude-3-opus")
+- `temperature`: Sampling temperature (defaults to 1)
+- `topP`: Top-p sampling
+- `maxTokens`: Maximum response tokens
+- `apiKey`: API key (auto-detected from `ANTHROPIC_API_KEY` env var)
+- `maxRetries`: Request retry limit (defaults to 10)
+- `timeout`: Request timeout in ms (defaults to 60 seconds)
+
+## Usage Examples
+
+### Basic LLM Usage
+
+```typescript
+import { Anthropic } from "@llamaindex/anthropic";
+
+const llm = new Anthropic({
+  model: "claude-3-5-sonnet",
+  temperature: 0.7,
+  maxTokens: 1024,
+});
+
+const response = await llm.chat({
+  messages: [{ role: "user", content: "Hello, how are you?" }],
+});
+```
+
+## Architecture Notes
+
+### Session Management
+
+The package implements session pooling to reuse connections efficiently. Sessions are automatically created and reused based on matching client options.
+
+### Message Formatting
+
+- System messages are extracted and handled separately
+- Consecutive messages from the same role are automatically merged
+- Tool calls and results are properly formatted for Anthropic's API
+- Multi-modal content (images, PDFs) is converted to base64 format
+
+### Tool Integration
+
+- Implements `BaseTool` interface from `@llamaindex/core`
+- Tool parameters must be object schemas
+- Automatic JSON parsing and validation of tool inputs
+- Streaming support for tool call responses
+
+## Testing
+
+The package includes comprehensive test coverage for:
+
+- Basic message formatting
+- Multi-modal content handling
+- Tool call and result formatting
+- Extended thinking block formatting
+- Consecutive message merging
+- Error handling for invalid inputs
+
+Tests use Vitest and mock the Anthropic API key for testing.
+
+## Dependencies
+
+- `@anthropic-ai/sdk`: Official Anthropic SDK
+- `remeda`: Utility library for deep equality checks
+- `@llamaindex/core`: Core LlamaIndex interfaces (peer dependency)
+- `@llamaindex/env`: Environment utilities (peer dependency)
+
+## Environment Variables
+
+- `ANTHROPIC_API_KEY`: Required API key for Anthropic services
+
+## Important Notes
+
+- Tool calling is only supported on Claude 3+ models
+- Agent streaming is not currently supported (throws error)
+- PDF files are the only supported document type for file uploads
+- Always ensure `thinking_signature` is provided when using thinking blocks
+- The package follows LlamaIndex provider patterns for consistent integration

packages/providers/anthropic/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@llamaindex/anthropic",
   "description": "Anthropic Adapter for LlamaIndex",
-  "version": "0.3.9",
+  "version": "0.3.11",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",

packages/providers/anthropic/src/llm.ts

@@ -28,7 +28,7 @@ import type {
 } from "@llamaindex/core/llms";
 import { ToolCallLLM } from "@llamaindex/core/llms";
 import { extractText } from "@llamaindex/core/utils";
-import { getEnv, uint8ArrayToBase64 } from "@llamaindex/env";
+import { getEnv } from "@llamaindex/env";
 import { isDeepEqual } from "remeda";
 
 export class AnthropicSession {
@@ -187,7 +187,7 @@ export class Anthropic extends ToolCallLLM<
   }
 
   get supportToolCall() {
-    return this.model.startsWith("claude-3");
+    return this.model.includes("-3") || this.model.includes("-4");
   }
 
   get metadata() {
@@ -342,7 +342,7 @@ export class Anthropic extends ToolCallLLM<
               source: {
                 type: "base64" as const,
                 media_type: content.mimeType,
-                data: uint8ArrayToBase64(content.data),
+                data: content.data,
               },
             };
           }

packages/providers/anthropic/tests/index.test.ts

@@ -178,7 +178,7 @@ describe("Message Formatting", () => {
             {
               type: "file",
               mimeType: "application/pdf",
-              data: pdfBuffer,
+              data: pdfBuffer.toString("base64"),
             },
           ],
           role: "user",

packages/providers/assemblyai/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @llamaindex/assemblyai
 
+## 0.1.8
+
+### Patch Changes
+
+- Updated dependencies [71598f8]
+  - @llamaindex/core@0.6.9
+
+## 0.1.7
+
+### Patch Changes
+
+- Updated dependencies [c927457]
+  - @llamaindex/core@0.6.8
+
 ## 0.1.6
 
 ### Patch Changes

packages/providers/assemblyai/CLAUDE.md

@@ -0,0 +1,98 @@
+# CLAUDE.md - @llamaindex/assemblyai
+
+This package provides AssemblyAI reader implementations for LlamaIndex, enabling audio transcription and processing capabilities.
+
+## Package Overview
+
+**Package Name:** `@llamaindex/assemblyai`  
+**Description:** AssemblyAI Reader for LlamaIndex  
+**Version:** 0.1.6  
+**Type:** Provider package for audio transcription and data ingestion
+
+## Architecture
+
+This package implements the BaseReader interface from `@llamaindex/core/schema` to provide audio transcription capabilities using AssemblyAI's API.
+
+### Core Components
+
+- `AssemblyAIReader` - Abstract base class implementing BaseReader<Document>
+- `AudioTranscriptReader` - Returns full transcript as single document
+- `AudioTranscriptParagraphsReader` - Returns transcript split by paragraphs
+- `AudioTranscriptSentencesReader` - Returns transcript split by sentences
+- `AudioSubtitlesReader` - Returns subtitles in SRT or VTT format
+
+### Key Files
+
+- `src/reader.ts` - Main implementation with all reader classes
+- `src/index.ts` - Re-exports all readers and types
+
+## Dependencies
+
+- `assemblyai` (^4.8.0) - Official AssemblyAI SDK
+- `@llamaindex/core` (workspace) - Core interfaces and Document class
+- `@llamaindex/env` (workspace) - Environment utilities for API key handling
+
+## Configuration
+
+### API Key Setup
+
+The package requires an AssemblyAI API key configured via:
+
+1. Constructor option: `new AudioTranscriptReader({ apiKey: "your-key" })`
+2. Environment variable: `ASSEMBLYAI_API_KEY`
+
+### Default Options
+
+The package sets default user agent information for AssemblyAI integration tracking:
+
+```typescript
+{
+  userAgent: {
+    integration: {
+      name: "LlamaIndexTS",
+      version: "1.0.1"
+    }
+  }
+}
+```
+
+## Usage Patterns
+
+### Basic Transcription
+
+```typescript
+import { AudioTranscriptReader } from "@llamaindex/assemblyai";
+
+const reader = new AudioTranscriptReader();
+const documents = await reader.loadData("path/to/audio.mp3");
+```
+
+### Paragraph-based Processing
+
+```typescript
+import { AudioTranscriptParagraphsReader } from "@llamaindex/assemblyai";
+
+const reader = new AudioTranscriptParagraphsReader();
+const paragraphDocs = await reader.loadData(transcribeParams);
+```
+
+### Existing Transcript Processing
+
+All readers support both new transcription and existing transcript retrieval:
+
+- Pass `TranscribeParams` object for new transcription
+- Pass transcript ID string to retrieve existing transcript
+
+## Build and Development
+
+- `pnpm build` - Build package using bunchee
+- `pnpm dev` - Watch mode development
+- Built files output to `dist/` directory with dual CJS/ESM support
+
+## Implementation Notes
+
+- Uses dynamic imports for the AssemblyAI SDK to support tree-shaking
+- Lazy-loads client via Promise to defer initialization
+- All readers extend the abstract base class for consistent behavior
+- Error handling for missing API keys with descriptive messages
+- Support for both audio file URLs and local file paths via AssemblyAI SDK

packages/providers/assemblyai/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@llamaindex/assemblyai",
   "description": "AssemblyAI Reader for LlamaIndex",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "type": "module",
   "types": "dist/index.d.ts",
   "main": "dist/index.cjs",

packages/providers/aws/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @llamaindex/community
 
+## 0.0.104
+
+### Patch Changes
+
+- Updated dependencies [71598f8]
+  - @llamaindex/core@0.6.9
+
+## 0.0.103
+
+### Patch Changes
+
+- Updated dependencies [c927457]
+  - @llamaindex/core@0.6.8
+
 ## 0.0.102
 
 ### Patch Changes

packages/providers/aws/CLAUDE.md

@@ -0,0 +1,151 @@
+# CLAUDE.md - AWS Provider Package
+
+This file provides guidance for working with the `@llamaindex/aws` provider package, which provides AWS Bedrock integration for LlamaIndex.TS.
+
+## Package Overview
+
+The `@llamaindex/aws` package provides AWS Bedrock LLM support and Amazon Knowledge Base retrieval capabilities. It integrates with AWS services through the AWS SDK v3.
+
+### Core Components
+
+- **Bedrock LLM Provider** (`src/llm/bedrock/`) - Multi-provider LLM implementation supporting various models through AWS Bedrock
+- **Knowledge Base Retriever** (`src/retrievers/bedrock.ts`) - Retrieval from Amazon Bedrock Knowledge Bases
+
+## Architecture
+
+### Provider Pattern
+
+The Bedrock implementation uses a provider pattern with separate implementations for different model families:
+
+- `anthropic/` - Anthropic Claude models (Claude 3.x, 4.x series)
+- `amazon/` - Amazon Nova models (Premier, Pro, Lite, Micro)
+- `meta/` - Meta Llama models (2.x, 3.x series) with tool calling support
+
+Each provider implements the abstract `Provider` class in `provider.ts:22-63` and handles:
+
+- Request body formatting for specific model APIs
+- Response parsing for both streaming and non-streaming
+- Tool calling integration where supported
+- Stream processing with proper delta handling
+
+### Model Support
+
+**Supported Model Families:**
+
+- **Anthropic Claude**: 3.x (Haiku, Sonnet, Opus), 3.5 (Haiku, Sonnet v1/v2), 3.7 Sonnet, 4.x (Sonnet, Opus)
+- **Amazon Nova**: Premier, Pro, Lite, Micro (all v1)
+- **Meta Llama**: 2.x (13B, 70B), 3.x (8B, 70B), 3.1 (8B, 70B, 405B), 3.2 (1B, 3B, 11B, 90B), 3.3 (70B)
+- **Legacy**: AI21 Jurassic, Cohere Command, Mistral (7B, Mixtral), Amazon Titan
+
+**Cross-Region Inference:**
+The package supports AWS cross-region inference with `INFERENCE_BEDROCK_MODELS` mapping to standard models via `INFERENCE_TO_BEDROCK_MAP` in `index.ts:142-209`.
+
+### Tool Calling Support
+
+Tool calling is available on models listed in `TOOL_CALL_MODELS` (`index.ts:306-326`):
+
+- All Claude 3.x+ models
+- Meta Llama 3.1 405B and all Llama 3.2+ models
+- All Amazon Nova models
+
+### Streaming Support
+
+Streaming is available for models in `STREAMING_MODELS` set (`index.ts:269-304`). The implementation handles provider-specific streaming protocols.
+
+## Development Patterns
+
+### Adding New Model Providers
+
+1. Create provider directory in `src/llm/bedrock/{provider}/`
+2. Implement `Provider` abstract class with required methods:
+   - `getTextFromResponse()` - Extract text from API response
+   - `getToolsFromResponse()` - Extract tool calls from response
+   - `getRequestBody()` - Format request for provider API
+   - `reduceStream()` - Handle streaming responses (if needed)
+3. Add to `PROVIDERS` object in `index.ts:33-37`
+4. Update model constants and support arrays
+
+### Model Configuration
+
+Models are defined in `BEDROCK_MODELS` (`index.ts:52-94`) with associated metadata:
+
+- Context windows in `BEDROCK_FOUNDATION_LLMS` (`index.ts:262`)
+- Max output tokens in `BEDROCK_MODEL_MAX_TOKENS` (`index.ts:348-371`)
+- Streaming/tool support in respective sets/arrays
+
+### Authentication
+
+The package relies on AWS SDK v3 default credential chain. No explicit credential handling is implemented - authentication is handled by:
+
+- Environment variables (`AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, `AWS_REGION`)
+- IAM roles, AWS profiles, or other AWS SDK authentication methods
+
+## Usage Patterns
+
+### Basic LLM Usage
+
+```typescript
+import { Bedrock, BEDROCK_MODELS } from "@llamaindex/aws";
+
+const llm = new Bedrock({
+  model: BEDROCK_MODELS.ANTHROPIC_CLAUDE_3_5_SONNET,
+  region: "us-east-1",
+  temperature: 0.7,
+  maxTokens: 2048,
+});
+```
+
+### Knowledge Base Retrieval
+
+```typescript
+import { AmazonKnowledgeBaseRetriever } from "@llamaindex/aws";
+
+const retriever = new AmazonKnowledgeBaseRetriever({
+  knowledgeBaseId: "YOUR_KB_ID",
+  region: "us-east-1",
+  topK: 10,
+});
+```
+
+### Cross-Region Inference
+
+```typescript
+import { INFERENCE_BEDROCK_MODELS } from "@llamaindex/aws";
+
+const llm = new Bedrock({
+  model: INFERENCE_BEDROCK_MODELS.US_ANTHROPIC_CLAUDE_4_SONNET,
+  region: "us-west-2", // Different from model prefix
+});
+```
+
+## Build and Dependencies
+
+- Built with `bunchee` for dual CJS/ESM output
+- Dependencies: AWS SDK v3 (`@aws-sdk/client-bedrock-runtime`, `@aws-sdk/client-bedrock-agent-runtime`)
+- Peer dependencies: `@llamaindex/core`, `@llamaindex/env`
+
+## Export Structure
+
+The package exports are organized as:
+
+- Main export: Core Bedrock class and constants
+- Subpath export: `./llm/bedrock` for direct Bedrock access
+- Retriever export: Knowledge Base retriever
+
+## Testing and Development
+
+When developing or testing:
+
+1. Ensure AWS credentials are configured
+2. Test with multiple model providers to verify provider pattern
+3. Test both streaming and non-streaming modes
+4. Verify tool calling with supported models
+5. Test cross-region inference models if applicable
+
+## Common Issues
+
+- **Authentication**: Ensure proper AWS credentials are configured
+- **Region Mismatch**: Verify model availability in target region
+- **Tool Calling**: Check model support before enabling tools
+- **Streaming**: Verify model supports streaming before using
+- **Token Limits**: Respect model-specific max token limits in `BEDROCK_MODEL_MAX_TOKENS`

packages/providers/aws/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@llamaindex/aws",
   "description": "AWS package for LlamaIndexTS",
-  "version": "0.0.102",
+  "version": "0.0.104",
   "type": "module",
   "types": "dist/type/index.d.ts",
   "main": "dist/cjs/index.js",

packages/providers/clip/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @llamaindex/clip
 
+## 0.0.59
+
+### Patch Changes
+
+- Updated dependencies [71598f8]
+  - @llamaindex/core@0.6.9
+  - @llamaindex/openai@0.4.3
+
+## 0.0.58
+
+### Patch Changes
+
+- Updated dependencies [c927457]
+  - @llamaindex/openai@0.4.2
+  - @llamaindex/core@0.6.8
+
 ## 0.0.57
 
 ### Patch Changes

packages/providers/clip/CLAUDE.md

@@ -0,0 +1,91 @@
+# CLAUDE.md - @llamaindex/clip
+
+This package provides CLIP (Contrastive Language-Image Pre-training) embedding functionality for LlamaIndex.TS, enabling multimodal embeddings for both text and images.
+
+## Package Overview
+
+**Package Name:** `@llamaindex/clip`  
+**Purpose:** CLIP embedding adapter that provides multimodal embeddings using Hugging Face Transformers.js  
+**Runtime Support:** Node.js only (not supported in edge/workerd environments due to transformer model requirements)
+
+## Core Components
+
+### ClipEmbedding Class (`src/embedding.ts`)
+
+Main embedding class that extends `MultiModalEmbedding` from `@llamaindex/core/embeddings`:
+
+- **Text Embeddings:** Generates embeddings for text inputs using CLIP's text model
+- **Image Embeddings:** Generates embeddings for images (Blob, URL, or string paths) using CLIP's vision model
+- **Model Support:** Uses Hugging Face Transformers.js with pre-trained CLIP models
+- **Lazy Loading:** Models, tokenizers, and processors are loaded on-demand and cached
+
+#### Key Methods:
+
+- `getTextEmbedding(text: string)`: Returns text embedding as number array
+- `getImageEmbedding(image: ImageType)`: Returns image embedding as number array
+- Private model getters: `getTokenizer()`, `getProcessor()`, `getVisionModel()`, `getTextModel()`
+
+### Supported Models (`src/shared.ts`)
+
+```typescript
+enum ClipEmbeddingModelType {
+  XENOVA_CLIP_VIT_BASE_PATCH32 = "Xenova/clip-vit-base-patch32",
+  XENOVA_CLIP_VIT_BASE_PATCH16 = "Xenova/clip-vit-base-patch16", // default
+}
+```
+
+## Dependencies
+
+- **Core:** `@huggingface/transformers` ^3.5.0 for CLIP model execution
+- **LlamaIndex:** `@llamaindex/core`, `@llamaindex/env` for base classes and environment handling
+- **Workspace:** `@llamaindex/openai` (dependency, likely for fallback or integration)
+
+## Runtime Support
+
+**Node.js:** ✅ Full support with Hugging Face Transformers.js  
+**Edge/Workerd:** ❌ Not supported - uses `NotSupportCurrentRuntimeClass` binding
+
+The package exports different entry points:
+
+- `index.ts`: Full Node.js implementation
+- `index.edge-light.ts`, `index.workerd.ts`: Both redirect to `index.non-node.ts`
+- `index.non-node.ts`: Exports stub class that throws runtime not supported error
+
+## Image Input Support
+
+The `readImage()` helper function supports multiple image input types:
+
+- **Blob:** Direct blob processing
+- **string/URL:** Image URLs or file paths
+- Throws error for unsupported input types
+
+## Usage Example
+
+```typescript
+import { ClipEmbedding, ClipEmbeddingModelType } from "@llamaindex/clip";
+
+const clipEmbedding = new ClipEmbedding();
+// Uses default model: XENOVA_CLIP_VIT_BASE_PATCH16
+
+// Get text embedding
+const textEmbedding = await clipEmbedding.getTextEmbedding("A photo of a cat");
+
+// Get image embedding
+const imageEmbedding =
+  await clipEmbedding.getImageEmbedding("path/to/image.jpg");
+// or with URL: await clipEmbedding.getImageEmbedding("https://example.com/image.jpg");
+// or with Blob: await clipEmbedding.getImageEmbedding(imageBlob);
+```
+
+## Development Commands
+
+- `pnpm build`: Build package using bunchee
+- `pnpm dev`: Build in watch mode
+- Test from workspace root: `turbo run test --filter="@llamaindex/clip"`
+
+## Integration Notes
+
+- Integrates with LlamaIndex event system via `Settings.callbackManager` for transformer loading events
+- Models are lazy-loaded and cached to optimize performance
+- Supports the standard LlamaIndex MultiModalEmbedding interface for consistency across embedding providers
+- Text and image embeddings are designed to be comparable in the same vector space (CLIP's key feature)

packages/providers/clip/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@llamaindex/clip",
   "description": "Clip Embedding Adapter for LlamaIndex",
-  "version": "0.0.57",
+  "version": "0.0.59",
   "type": "module",
   "types": "dist/index.d.ts",
   "main": "dist/index.cjs",

packages/providers/cohere/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @llamaindex/cohere
 
+## 0.0.23
+
+### Patch Changes
+
+- Updated dependencies [71598f8]
+  - @llamaindex/core@0.6.9
+
+## 0.0.22
+
+### Patch Changes
+
+- Updated dependencies [c927457]
+  - @llamaindex/core@0.6.8
+
 ## 0.0.21
 
 ### Patch Changes

packages/providers/cohere/CLAUDE.md

@@ -0,0 +1,92 @@
+# CLAUDE.md - @llamaindex/cohere
+
+This package provides Cohere integration for LlamaIndex.TS, specifically implementing Cohere's reranking capabilities.
+
+## Package Overview
+
+**Package Name:** `@llamaindex/cohere`  
+**Description:** Cohere Adapter for LlamaIndex  
+**Version:** 0.0.21
+
+This is a provider package that integrates Cohere's reranking API with the LlamaIndex.TS framework.
+
+## Architecture
+
+### Core Components
+
+- **CohereRerank** (`src/CohereRerank.ts`): Main class implementing `BaseNodePostprocessor` interface for document reranking
+
+### Dependencies
+
+- **External:** `cohere-ai` (v7.14.0) - Official Cohere SDK
+- **Internal:** `@llamaindex/core` - Core LlamaIndex interfaces and utilities
+
+## Key Features
+
+### Document Reranking
+
+The primary functionality is reranking search results using Cohere's rerank models:
+
+- Implements `BaseNodePostprocessor` interface for seamless integration with LlamaIndex pipelines
+- Uses Cohere's rerank API to improve search result relevance
+- Supports custom model selection and configuration
+
+### Configuration Options
+
+- `topN`: Number of top results to return (default: 2)
+- `model`: Cohere rerank model to use (default: "rerank-english-v2.0")
+- `apiKey`: Required Cohere API key
+- `baseUrl`: Optional custom API endpoint
+- `timeout`: Optional request timeout in seconds
+
+## Usage Pattern
+
+```typescript
+import { CohereRerank } from "@llamaindex/cohere";
+
+const reranker = new CohereRerank({
+  apiKey: "your-cohere-api-key",
+  topN: 5,
+  model: "rerank-english-v2.0",
+});
+
+// Use as a node postprocessor in retrieval pipeline
+const rerankedNodes = await reranker.postprocessNodes(nodes, query);
+```
+
+## Implementation Details
+
+### CohereRerank Class (`src/CohereRerank.ts:17`)
+
+- Implements `BaseNodePostprocessor` interface
+- Manages CohereClient instance for API communication
+- Extracts text content from nodes using `MetadataMode.ALL`
+- Maps Cohere relevance scores back to LlamaIndex `NodeWithScore` format
+- Preserves original nodes while updating relevance scores
+
+### Error Handling
+
+- Validates API key presence during construction
+- Requires query parameter for reranking operation
+- Handles empty node arrays gracefully
+- Validates client initialization before API calls
+
+## Build Configuration
+
+- Uses `bunchee` for building with dual CJS/ESM support
+- Exports both CommonJS and ES module formats
+- Includes TypeScript declarations for both formats
+- Follows LlamaIndex.TS provider package conventions
+
+## Development Commands
+
+- `pnpm build` - Build the package
+- `pnpm dev` - Build in watch mode
+
+## Integration Points
+
+This package integrates with:
+
+- LlamaIndex.TS retrieval pipelines as a node postprocessor
+- Any component that processes `NodeWithScore[]` arrays
+- Query engines that benefit from result reranking

packages/providers/cohere/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@llamaindex/cohere",
   "description": "Cohere Adapter for LlamaIndex",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",

packages/providers/deepinfra/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @llamaindex/deepinfra
 
+## 0.0.59
+
+### Patch Changes
+
+- Updated dependencies [71598f8]
+  - @llamaindex/core@0.6.9
+  - @llamaindex/openai@0.4.3
+
+## 0.0.58
+
+### Patch Changes
+
+- Updated dependencies [c927457]
+  - @llamaindex/openai@0.4.2
+  - @llamaindex/core@0.6.8
+
 ## 0.0.57
 
 ### Patch Changes

packages/providers/deepinfra/CLAUDE.md

@@ -0,0 +1,98 @@
+# CLAUDE.md - DeepInfra Provider Package
+
+This package provides LLM and embedding integrations for DeepInfra's AI platform in LlamaIndex.TS.
+
+## Package Overview
+
+The `@llamaindex/deepinfra` package offers two main components:
+
+1. **DeepInfra LLM** - OpenAI-compatible chat model interface using DeepInfra's hosted models
+2. **DeepInfraEmbedding** - Native embedding API integration for text embeddings
+
+## Architecture
+
+### LLM Integration (src/llm.ts)
+
+The `DeepInfra` class extends the OpenAI class from `@llamaindex/openai`, leveraging DeepInfra's OpenAI-compatible API:
+
+- **Base URL**: `https://api.deepinfra.com/v1/openai`
+- **Default Model**: `mistralai/Mixtral-8x22B-Instruct-v0.1`
+- **Authentication**: Uses `DEEPINFRA_API_TOKEN` environment variable
+- **Implementation**: Wrapper around OpenAI class with DeepInfra-specific defaults
+
+### Embedding Integration (src/embedding.ts)
+
+The `DeepInfraEmbedding` class implements the `BaseEmbedding` interface:
+
+- **Base URL**: `https://api.deepinfra.com/v1/inference`
+- **Default Model**: `sentence-transformers/clip-ViT-B-32`
+- **Features**: Custom query/text prefixes, retry logic, timeout handling
+- **Response**: Includes inference status with runtime metrics and cost information
+
+## Configuration
+
+### Environment Variables
+
+- `DEEPINFRA_API_TOKEN` - Required API token for both LLM and embedding services
+
+### LLM Configuration
+
+```typescript
+import { DeepInfra } from "@llamaindex/deepinfra";
+
+const llm = new DeepInfra({
+  model: "mistralai/Mixtral-8x22B-Instruct-v0.1", // optional
+  apiKey: "your-api-key", // optional if DEEPINFRA_API_TOKEN is set
+  // ... other OpenAI-compatible options
+});
+```
+
+### Embedding Configuration
+
+```typescript
+import { DeepInfraEmbedding } from "@llamaindex/deepinfra";
+
+const embedding = new DeepInfraEmbedding({
+  model: "sentence-transformers/clip-ViT-B-32", // optional
+  apiToken: "your-api-key", // optional if DEEPINFRA_API_TOKEN is set
+  queryPrefix: "search_query: ", // optional
+  textPrefix: "search_document: ", // optional
+  maxRetries: 5, // optional
+  timeout: 60000, // optional
+});
+```
+
+## Key Features
+
+### LLM Features
+
+- Full OpenAI API compatibility through inheritance
+- Automatic API key management from environment
+- Support for all DeepInfra hosted models
+
+### Embedding Features
+
+- Batch embedding support
+- Automatic retry logic with exponential backoff
+- Configurable timeouts and retry limits
+- Query/text prefix support for different embedding use cases
+- Detailed inference status reporting (runtime, cost, tokens)
+
+## Dependencies
+
+- `@llamaindex/core` - Core interfaces and utilities
+- `@llamaindex/env` - Environment variable handling
+- `@llamaindex/openai` - OpenAI implementation (for LLM)
+
+## Development
+
+- **Build**: `pnpm build` (uses bunchee)
+- **Watch**: `pnpm dev` (uses bunchee --watch)
+- **Output**: Dual CJS/ESM exports in `dist/`
+
+## API Endpoints
+
+- **LLM**: Uses OpenAI-compatible endpoint at `/v1/openai`
+- **Embeddings**: Uses native DeepInfra inference endpoint at `/v1/inference/{model}`
+
+This package follows the LlamaIndex.TS provider pattern, implementing standard interfaces while providing DeepInfra-specific optimizations and features.

packages/providers/deepinfra/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@llamaindex/deepinfra",
   "description": "Deepinfra Adapter for LlamaIndex",
-  "version": "0.0.57",
+  "version": "0.0.59",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",