chore: implement claude suggestions

.changeset/shy-shoes-bow.md

@@ -0,0 +1,5 @@
+---
+"llama-cloud-services": patch
+---
+
+Adding LlamaClassify among the available LlamaCloud services

.github/workflows/build_package_py.yml

@@ -27,7 +27,7 @@ jobs:
       - uses: actions/checkout@v5
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v6
+        uses: astral-sh/setup-uv@v7
         with:
           version: ${{ env.UV_VERSION }}
 

.github/workflows/codeql.yml

@@ -30,12 +30,12 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v3
+        uses: github/codeql-action/init@v4
         with:
           languages: python
           dependency-caching: true
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v3
+        uses: github/codeql-action/analyze@v4
         with:
           category: "/language:python"

.github/workflows/lint.yml

@@ -22,7 +22,7 @@ jobs:
         with:
           fetch-depth: ${{ github.event_name == 'pull_request' && 2 || 0 }}
       - name: Install uv
-        uses: astral-sh/setup-uv@v6
+        uses: astral-sh/setup-uv@v7
         with:
           version: ${{ env.UV_VERSION }}
 

.github/workflows/test_e2e_py.yml

@@ -22,7 +22,7 @@ jobs:
         with:
           fetch-depth: 0
       - name: Install uv
-        uses: astral-sh/setup-uv@v6
+        uses: astral-sh/setup-uv@v7
         with:
           version: ${{ env.UV_VERSION }}
 

.github/workflows/test_py.yml

@@ -26,7 +26,7 @@ jobs:
         with:
           fetch-depth: 0
       - name: Install uv
-        uses: astral-sh/setup-uv@v6
+        uses: astral-sh/setup-uv@v7
         with:
           version: ${{ env.UV_VERSION }}
 

.github/workflows/version_bump_and_release.yml

@@ -31,7 +31,7 @@ jobs:
           python-version: "3.11"
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v6
+        uses: astral-sh/setup-uv@v7
 
       - name: Install dependencies
         run: pnpm install

py/CHANGELOG.md

@@ -1,5 +1,17 @@
 # llama-cloud-services-py
 
+## 0.6.76
+
+### Patch Changes
+
+- 4f24f53: Add aggressive_table_extraction flag in python sdk
+
+## 0.6.75
+
+### Patch Changes
+
+- f81532e: Safest types possible for parse
+
 ## 0.6.74
 
 ### Patch Changes

py/llama_cloud_services/parse/base.py

@@ -188,6 +188,10 @@ class LlamaParse(BasePydanticReader):
         default=False,
         description="If set to true, LlamaParse will try to detect long table and adapt the output.",
     )
+    aggressive_table_extraction: Optional[bool] = Field(
+        default=False,
+        description="If set to true, LlamaParse will try to extract tables aggressively, may lead to false positives.",
+    )
     annotate_links: Optional[bool] = Field(
         default=False,
         description="Annotate links found in the document to extract their URL.",
@@ -713,6 +717,9 @@ class LlamaParse(BasePydanticReader):
         if self.adaptive_long_table:
             data["adaptive_long_table"] = self.adaptive_long_table
 
+        if self.aggressive_table_extraction:
+            data["aggressive_table_extraction"] = self.aggressive_table_extraction
+
         if self.annotate_links:
             data["annotate_links"] = self.annotate_links
 

py/llama_cloud_services/parse/types.py

@@ -1,8 +1,8 @@
 import httpx
 import os
 import re
-from pydantic import BaseModel, Field, SerializeAsAny
-from typing import Dict, Any, List, Optional
+from pydantic import BaseModel, ConfigDict, Field, SerializeAsAny, model_validator
+from typing import Dict, Any, List, Optional, get_origin, get_args
 
 from llama_cloud_services.parse.utils import (
     make_api_request,
@@ -13,8 +13,75 @@ from llama_index.core.schema import Document, ImageDocument, ImageNode, TextNode
 
 PAGE_REGEX = r"page[-_](\d+)\.jpg$"
 
+SAFE_MODEL_CONFIGS = ConfigDict(
+    extra="allow",
+    validate_assignment=False,
+    arbitrary_types_allowed=True,
+    validate_default=False,
+)
 
-class JobMetadata(BaseModel):
+
+class SafeBaseModel(BaseModel):
+    """Base model that gracefully handles None values from unstable backend responses."""
+
+    model_config = SAFE_MODEL_CONFIGS
+
+    @model_validator(mode="before")
+    @classmethod
+    def coerce_none_to_defaults(cls, data: Any) -> Any:
+        """
+        Replace None values with appropriate defaults based on field type annotations.
+        This prevents validation errors when the backend returns None for non-optional fields.
+        """
+        if not isinstance(data, dict):
+            return data
+
+        # Process each field that has a None value
+        result = {}
+        for key, value in data.items():
+            if value is not None or key not in cls.model_fields:
+                result[key] = value
+                continue
+
+            # Value is None and field exists in model
+            field_info = cls.model_fields[key]
+
+            # If field has a default or default_factory, let Pydantic handle it
+            from pydantic_core import PydanticUndefined
+
+            if (
+                field_info.default is not PydanticUndefined
+                or field_info.default_factory is not None
+            ):
+                continue
+
+            # Otherwise, provide a sensible default based on the type annotation
+            annotation = field_info.annotation
+            origin = get_origin(annotation)
+
+            # Handle List types
+            if origin is list:
+                result[key] = []
+            # Handle Dict types
+            elif origin is dict:
+                result[key] = {}
+            # Handle basic types
+            elif annotation == str or (origin and str in get_args(annotation)):
+                result[key] = ""
+            elif annotation == int or (origin and int in get_args(annotation)):
+                result[key] = 0
+            elif annotation == float or (origin and float in get_args(annotation)):
+                result[key] = 0.0
+            elif annotation == bool or (origin and bool in get_args(annotation)):
+                result[key] = False
+            # If we can't determine a safe default, skip (let Pydantic try)
+            else:
+                result[key] = value
+
+        return result
+
+
+class JobMetadata(SafeBaseModel):
     """Metadata about the job."""
 
     job_pages: int = Field(default=0, description="The number of pages in the job.")
@@ -27,7 +94,7 @@ class JobMetadata(BaseModel):
     )
 
 
-class BBox(BaseModel):
+class BBox(SafeBaseModel):
     """A bounding box."""
 
     x: Optional[float] = Field(
@@ -48,10 +115,10 @@ class BBox(BaseModel):
     )
 
 
-class PageItem(BaseModel):
+class PageItem(SafeBaseModel):
     """An item in a page."""
 
-    type: str = Field(description="The type of the item.")
+    type: str = Field(default="", description="The type of the item.")
     lvl: Optional[int] = Field(
         default=None, description="The level of indentation of the item."
     )
@@ -73,10 +140,10 @@ class PageItem(BaseModel):
     )
 
 
-class ImageItem(BaseModel):
+class ImageItem(SafeBaseModel):
     """An image in a page."""
 
-    name: str = Field(description="The name of the image.")
+    name: str = Field(default="", description="The name of the image.")
     height: Optional[float] = Field(
         default=None, description="The height of the image."
     )
@@ -96,14 +163,16 @@ class ImageItem(BaseModel):
     type: Optional[str] = Field(default=None, description="The type of the image.")
 
 
-class LayoutItem(BaseModel):
+class LayoutItem(SafeBaseModel):
     """The layout of a page."""
 
-    image: str = Field(description="The name of the image containing the layout item")
+    image: str = Field(
+        default="", description="The name of the image containing the layout item"
+    )
     confidence: float = Field(
         default=0.0, description="The confidence of the layout item."
     )
-    label: str = Field(description="The label of the layout item.")
+    label: str = Field(default="", description="The label of the layout item.")
     bbox: Optional[BBox] = Field(
         default=None, description="The bounding box of the layout item."
     )
@@ -112,10 +181,10 @@ class LayoutItem(BaseModel):
     )
 
 
-class ChartItem(BaseModel):
+class ChartItem(SafeBaseModel):
     """A chart in a page."""
 
-    name: str = Field(description="The name of the chart.")
+    name: str = Field(default="", description="The name of the chart.")
     x: Optional[float] = Field(
         default=None, description="The x-coordinate of the chart."
     )
@@ -128,7 +197,7 @@ class ChartItem(BaseModel):
     )
 
 
-class Page(BaseModel):
+class Page(SafeBaseModel):
     """A page of the document."""
 
     page: int = Field(default=0, description="The page number.")
@@ -183,7 +252,7 @@ class Page(BaseModel):
     )
 
 
-class JobResult(BaseModel):
+class JobResult(SafeBaseModel):
     """The raw JSON result from the LlamaParse API."""
 
     pages: List[Page] = Field(

py/llama_parse/CHANGELOG.md

@@ -1,5 +1,19 @@
 # llama_parse
 
+## 0.6.76
+
+### Patch Changes
+
+- Updated dependencies [4f24f53]
+  - llama-cloud-services-py@0.6.76
+
+## 0.6.75
+
+### Patch Changes
+
+- Updated dependencies [f81532e]
+  - llama-cloud-services-py@0.6.75
+
 ## 0.6.74
 
 ### Patch Changes

py/llama_parse/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llama_parse",
-  "version": "0.6.74",
+  "version": "0.6.76",
   "description": "",
   "main": "index.js",
   "private": false,

py/llama_parse/pyproject.toml

@@ -11,13 +11,13 @@ dev = [
 
 [project]
 name = "llama-parse"
-version = "0.6.74"
+version = "0.6.76"
 description = "Parse files into RAG-Optimized formats."
 authors = [{name = "Logan Markewich", email = "logan@llamaindex.ai"}]
 requires-python = ">=3.9,<4.0"
 readme = "README.md"
 license = "MIT"
-dependencies = ["llama-cloud-services>=0.6.74"]
+dependencies = ["llama-cloud-services>=0.6.76"]
 
 [project.scripts]
 llama-parse = "llama_parse.cli.main:parse"

py/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llama-cloud-services-py",
-  "version": "0.6.74",
+  "version": "0.6.76",
   "private": false,
   "license": "MIT",
   "scripts": {},

py/pyproject.toml

@@ -19,7 +19,7 @@ dev = [
 
 [project]
 name = "llama-cloud-services"
-version = "0.6.74"
+version = "0.6.76"
 description = "Tailored SDK clients for LlamaCloud services."
 authors = [{name = "Logan Markewich", email = "logan@runllama.ai"}]
 requires-python = ">=3.9,<4.0"

ts/e2e-tests/src/index.e2e.ts

@@ -9,10 +9,12 @@ test("LlamaIndex module resolution test", async (t) => {
     const index = new LlamaCloudIndex({
       name: "test-index",
       projectName: "Default",
+      apiKey: process.env.LLAMA_CLOUD_API_KEY || "test-key",
     });
     const reader = new LlamaParseReader({
       resultType: "markdown",
       verbose: false,
+      apiKey: process.env.LLAMA_CLOUD_API_KEY || "test-key",
     });
     ok(index !== undefined);
     ok(reader !== undefined);
@@ -24,6 +26,7 @@ test("LlamaIndex module resolution test", async (t) => {
     const index = new mod.LlamaCloudIndex({
       name: "test-index",
       projectName: "Default",
+      apiKey: process.env.LLAMA_CLOUD_API_KEY || "test-key",
     });
     ok(index !== undefined);
   });

ts/llama_cloud_services/CHANGELOG.md

@@ -1,5 +1,11 @@
 # llama-cloud-services
 
+## 0.3.9
+
+### Patch Changes
+
+- 5d4cabd: Add ImageNode support in TypeScript
+
 ## 0.3.8
 
 ### Patch Changes

ts/llama_cloud_services/classify/package.json

@@ -0,0 +1,8 @@
+{
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": "./dist/index.js",
+  "private": true
+}

ts/llama_cloud_services/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llama-cloud-services",
-  "version": "0.3.8",
+  "version": "0.3.9",
   "type": "module",
   "license": "MIT",
   "scripts": {
@@ -24,7 +24,8 @@
     "./reader",
     "./parse",
     "./beta/agent",
-    "./extract"
+    "./extract",
+    "./classify"
   ],
   "exports": {
     "./openapi.json": "./openapi.json",
@@ -83,6 +84,17 @@
       },
       "default": "./extract/dist/index.js"
     },
+    "./classify": {
+      "require": {
+        "types": "./classify/dist/index.d.cts",
+        "default": "./classify/dist/index.cjs"
+      },
+      "import": {
+        "types": "./classify/dist/index.d.ts",
+        "default": "./classify/dist/index.js"
+      },
+      "default": "./classify/dist/index.js"
+    },
     ".": {
       "require": {
         "types": "./dist/index.d.cts",

ts/llama_cloud_services/src/LlamaClassify.ts

@@ -0,0 +1,69 @@
+import { createClient, createConfig, type Client } from "@hey-api/client-fetch";
+import {
+  classify,
+  type ClassifyParsingConfiguration,
+  type ClassifierRule,
+  type ClassifyJobResults,
+} from "./classify";
+import { getUrl } from "./utils";
+import { getEnv } from "@llamaindex/env";
+import { File } from "buffer";
+
+export class LlamaClassify {
+  private client: Client;
+
+  constructor(
+    apiKey: string | undefined = undefined,
+    baseUrl: string | undefined = undefined,
+    region: string | undefined = undefined,
+  ) {
+    const key = apiKey ?? getEnv("LLAMA_CLOUD_API_KEY");
+    if (typeof key === "undefined") {
+      throw new Error(
+        "No API key provided and no API key found in environment. Please pass the API key or set `LLAMA_CLOUD_API_KEY` as an environment variable.",
+      );
+    }
+    const url = getUrl(baseUrl, region);
+    this.client = createClient(
+      createConfig({
+        baseUrl: url,
+        headers: {
+          Authorization: `Bearer ${key}`,
+        },
+      }),
+    );
+  }
+
+  async classify(
+    rules: ClassifierRule[],
+    parsingConfiguration: ClassifyParsingConfiguration,
+    fileContents:
+      | Buffer<ArrayBufferLike>[]
+      | File[]
+      | Uint8Array<ArrayBuffer>[]
+      | string[]
+      | undefined = undefined,
+    filePaths: string[] | undefined = undefined,
+    projectId: string | null = null,
+    organizationId: string | null = null,
+    pollingInterval: number = 1,
+    maxPollingIterations: number = 1800,
+    maxRetriesOnError: number = 10,
+    retryInterval: number = 0.5,
+  ): Promise<ClassifyJobResults> {
+    const result = await classify(
+      rules,
+      parsingConfiguration,
+      fileContents,
+      filePaths,
+      projectId,
+      organizationId,
+      this.client,
+      pollingInterval,
+      maxPollingIterations,
+      maxRetriesOnError,
+      retryInterval,
+    );
+    return result;
+  }
+}

ts/llama_cloud_services/src/LlamaCloudRetriever.ts

@@ -9,10 +9,16 @@ import { DEFAULT_PROJECT_NAME } from "@llamaindex/core/global";
 import type { QueryBundle } from "@llamaindex/core/query-engine";
 import { BaseRetriever } from "@llamaindex/core/retriever";
 import type { NodeWithScore } from "@llamaindex/core/schema";
-import { jsonToNode, ObjectType } from "@llamaindex/core/schema";
+import { jsonToNode, ObjectType, ImageNode } from "@llamaindex/core/schema";
 import { extractText } from "@llamaindex/core/utils";
 import type { ClientParams, CloudConstructorParams } from "./type.js";
-import { getPipelineId, initService } from "./utils.js";
+import { getPipelineId, getProjectId, initService } from "./utils.js";
+import {
+  type PageScreenshotNodeWithScore,
+  type PageFigureNodeWithScore,
+  generateFilePageScreenshotPresignedUrlApiV1FilesIdPageScreenshotsPageIndexPresignedUrlPost,
+  generateFilePageFigurePresignedUrlApiV1FilesIdPageFiguresPageIndexFigureNamePresignedUrlPost,
+} from "./api";
 
 export type CloudRetrieveParams = Omit<
   RetrievalParams,
@@ -43,6 +49,95 @@ export class LlamaCloudRetriever extends BaseRetriever {
     });
   }
 
+  private async fetchBase64FromPresignedUrl(url: string): Promise<string> {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch media from presigned URL: ${response.status} ${response.statusText}`,
+      );
+    }
+    const buffer = Buffer.from(await response.arrayBuffer());
+    return buffer.toString("base64");
+  }
+
+  private async pageScreenshotNodesToNodeWithScore(
+    nodes: PageScreenshotNodeWithScore[] | undefined,
+    projectId: string,
+  ): Promise<NodeWithScore[]> {
+    if (!nodes || nodes.length === 0) return [];
+
+    const results = await Promise.all(
+      nodes.map(async (n) => {
+        const { data: presigned } =
+          await generateFilePageScreenshotPresignedUrlApiV1FilesIdPageScreenshotsPageIndexPresignedUrlPost(
+            {
+              throwOnError: true,
+              path: {
+                id: n.node.file_id,
+                page_index: n.node.page_index,
+              },
+              query: {
+                project_id: projectId,
+                organization_id: this.organizationId ?? null,
+              },
+            },
+          );
+        const base64 = await this.fetchBase64FromPresignedUrl(presigned.url);
+        const imageNode = new ImageNode({
+          image: base64,
+          metadata: {
+            ...(n.node.metadata ?? {}),
+            file_id: n.node.file_id,
+            page_index: n.node.page_index,
+          },
+        });
+        return { node: imageNode, score: n.score } satisfies NodeWithScore;
+      }),
+    );
+
+    return results;
+  }
+
+  private async pageFigureNodesToNodeWithScore(
+    nodes: PageFigureNodeWithScore[] | undefined,
+    projectId: string,
+  ): Promise<NodeWithScore[]> {
+    if (!nodes || nodes.length === 0) return [];
+
+    const results = await Promise.all(
+      nodes.map(async (n) => {
+        const { data: presigned } =
+          await generateFilePageFigurePresignedUrlApiV1FilesIdPageFiguresPageIndexFigureNamePresignedUrlPost(
+            {
+              throwOnError: true,
+              path: {
+                id: n.node.file_id,
+                page_index: n.node.page_index,
+                figure_name: n.node.figure_name,
+              },
+              query: {
+                project_id: projectId,
+                organization_id: this.organizationId ?? null,
+              },
+            },
+          );
+        const base64 = await this.fetchBase64FromPresignedUrl(presigned.url);
+        const imageNode = new ImageNode({
+          image: base64,
+          metadata: {
+            ...(n.node.metadata ?? {}),
+            file_id: n.node.file_id,
+            page_index: n.node.page_index,
+            figure_name: n.node.figure_name,
+          },
+        });
+        return { node: imageNode, score: n.score } satisfies NodeWithScore;
+      }),
+    );
+
+    return results;
+  }
+
   // LlamaCloud expects null values for filters, but LlamaIndexTS uses undefined for empty values
   // This function converts the undefined values to null
   private convertFilter(filters?: MetadataFilters): MetadataFilters | null {
@@ -76,6 +171,35 @@ export class LlamaCloudRetriever extends BaseRetriever {
   }
 
   async _retrieve(query: QueryBundle): Promise<NodeWithScore[]> {
+    // Handle deprecated image retrieval flag
+    const retrieveImageNodes = (this.retrieveParams as RetrievalParams)
+      .retrieve_image_nodes;
+    if (typeof retrieveImageNodes !== "undefined") {
+      console.warn(
+        "The `retrieve_image_nodes` parameter is deprecated. Use `retrieve_page_screenshot_nodes` and `retrieve_page_figure_nodes` instead.",
+      );
+    }
+
+    const retrievePageScreenshotNodes = (this.retrieveParams as RetrievalParams)
+      .retrieve_page_screenshot_nodes;
+    const retrievePageFigureNodes = (this.retrieveParams as RetrievalParams)
+      .retrieve_page_figure_nodes;
+
+    if (retrieveImageNodes) {
+      if (
+        retrievePageScreenshotNodes === false ||
+        retrievePageFigureNodes === false
+      ) {
+        throw new Error(
+          "If `retrieve_image_nodes` is set to true, both `retrieve_page_screenshot_nodes` and `retrieve_page_figure_nodes` must also be set to true or omitted.",
+        );
+      }
+      (this.retrieveParams as RetrievalParams).retrieve_page_screenshot_nodes =
+        true;
+      (this.retrieveParams as RetrievalParams).retrieve_page_figure_nodes =
+        true;
+    }
+
     const pipelineId = await getPipelineId(
       this.pipelineName,
       this.projectName,
@@ -98,6 +222,34 @@ export class LlamaCloudRetriever extends BaseRetriever {
         },
       });
 
-    return this.resultNodesToNodeWithScore(results.retrieval_nodes);
+    const textNodes = this.resultNodesToNodeWithScore(results.retrieval_nodes);
+
+    const needScreenshots = (this.retrieveParams as RetrievalParams)
+      .retrieve_page_screenshot_nodes;
+    const needFigures = (this.retrieveParams as RetrievalParams)
+      .retrieve_page_figure_nodes;
+
+    if (!needScreenshots && !needFigures) {
+      return textNodes;
+    }
+
+    const projectId = await getProjectId(this.projectName, this.organizationId);
+
+    const [screenshotNodes, figureNodes] = await Promise.all([
+      needScreenshots
+        ? this.pageScreenshotNodesToNodeWithScore(
+            results.image_nodes,
+            projectId,
+          )
+        : Promise.resolve([] as NodeWithScore[]),
+      needFigures
+        ? this.pageFigureNodesToNodeWithScore(
+            results.page_figure_nodes,
+            projectId,
+          )
+        : Promise.resolve([] as NodeWithScore[]),
+    ]);
+
+    return [...textNodes, ...screenshotNodes, ...figureNodes];
   }
 }

ts/llama_cloud_services/src/LlamaExtract.ts

@@ -4,25 +4,7 @@ import * as extract from "./extract";
 import type { ExtractAgent, ExtractConfig } from "./extract";
 import { getEnv } from "@llamaindex/env";
 import type { ExtractResult } from "./type";
-
-const URLS = {
-  us: "https://api.cloud.llamaindex.ai",
-  eu: "https://api.cloud.eu.llamaindex.ai",
-  "us-staging": "https://api.staging.llamaindex.ai",
-} as const;
-
-function getUrl(baseUrl: string | undefined, region: string | undefined) {
-  if (typeof baseUrl != "undefined") {
-    return baseUrl;
-  }
-  if (typeof region === "undefined") {
-    return URLS["us"];
-  } else if (region === "us" || region === "eu" || region === "us-staging") {
-    return URLS[region];
-  } else {
-    throw new Error(`Unsupported region: ${region}`);
-  }
-}
+import { getUrl } from "./utils";
 
 export class LlamaExtractAgent {
   private agent: ExtractAgent;

ts/llama_cloud_services/src/classify.ts

@@ -0,0 +1,289 @@
+import type {
+  Options,
+  CreateClassifyJobApiV1ClassifierJobsPostData,
+  ClassifyJobCreate,
+  ClassifierRule,
+  ClassifyParsingConfiguration,
+  GetClassifyJobApiV1ClassifierJobsClassifyJobIdGetData,
+  GetClassificationJobResultsApiV1ClassifierJobsClassifyJobIdResultsGetData,
+  ClassifyJobResults,
+} from "./api";
+import {
+  StatusEnum,
+  createClassifyJobApiV1ClassifierJobsPost,
+  getClassifyJobApiV1ClassifierJobsClassifyJobIdGet,
+  getClassificationJobResultsApiV1ClassifierJobsClassifyJobIdResultsGet,
+} from "./api";
+import type { Client } from "@hey-api/client-fetch";
+import { sleep } from "./utils";
+import { uploadFile } from "./fileUpload";
+import { File } from "buffer";
+
+async function createClassifyJob(
+  fileIds: string[],
+  rules: ClassifierRule[],
+  parsingConfiguration: ClassifyParsingConfiguration,
+  organizationId: null | string,
+  projectId: null | string,
+  client: Client | undefined,
+  maxRetriesOnError: number = 10,
+  retryInterval: number = 0.5,
+): Promise<string> {
+  const rawData = {
+    file_ids: fileIds,
+    rules: rules,
+    parsing_configuration: parsingConfiguration,
+  } as ClassifyJobCreate;
+  const data = {
+    body: rawData,
+    query: {
+      project_id: projectId,
+      organization_id: organizationId,
+    },
+  } as CreateClassifyJobApiV1ClassifierJobsPostData;
+  const options = data as Options<CreateClassifyJobApiV1ClassifierJobsPostData>;
+  if (typeof client != "undefined") {
+    options.client = client;
+  }
+  let retries = 0;
+  while (true) {
+    if (retries > maxRetriesOnError) {
+      throw new Error(
+        "Error while creating the classify job: Exceeded maximum number of retries, the API keeps returning errors.",
+      );
+    }
+    const response = await createClassifyJobApiV1ClassifierJobsPost(options);
+    if (!response.response.ok) {
+      if ("error" in response) {
+        console.log(
+          `An error occurred while creating the classification job.\nDetails:\n\n${JSON.stringify(
+            response.error,
+          )}\n\nRetrying...`,
+        );
+      }
+      retries++;
+      await sleep(retryInterval * 1000);
+    } else {
+      if (typeof response.data != "undefined") {
+        return response.data.id;
+      } else {
+        throw new Error(
+          "Error while creating the classify job: the job creation succeeded but no data where returned",
+        );
+      }
+    }
+  }
+}
+
+async function pollForJobCompletion(
+  jobId: string,
+  interval: number = 1,
+  maxIterations: number = 1800,
+  client: Client | undefined = undefined,
+): Promise<boolean> {
+  let status: StatusEnum | undefined = undefined;
+  const jobData = {
+    path: { classify_job_id: jobId },
+  } as GetClassifyJobApiV1ClassifierJobsClassifyJobIdGetData;
+  const jobOptions =
+    jobData as Options<GetClassifyJobApiV1ClassifierJobsClassifyJobIdGetData>;
+  if (typeof client != "undefined") {
+    jobOptions.client = client;
+  }
+  let numIterations: number = 0;
+  while (true) {
+    if (numIterations > maxIterations) {
+      return false;
+    }
+    const response =
+      await getClassifyJobApiV1ClassifierJobsClassifyJobIdGet(jobOptions);
+    if (!response.response.ok) {
+      numIterations++;
+    }
+    if (typeof response.data != "undefined") {
+      status = response.data.status as StatusEnum;
+      if (status == StatusEnum.CANCELLED || status == StatusEnum.ERROR) {
+        throw new Error("There was an error during the classification job.");
+      } else if (status == StatusEnum.SUCCESS) {
+        return true;
+      } else {
+        numIterations++;
+        await sleep(interval * 1000);
+      }
+    }
+  }
+}
+
+async function getJobResult(
+  jobId: string,
+  client: Client | undefined = undefined,
+  projectId: string | null = null,
+  organizationId: string | null = null,
+  maxRetriesOnError: number = 10,
+  retryInterval: number = 0.5,
+): Promise<ClassifyJobResults> {
+  const jobData = {
+    path: { classify_job_id: jobId },
+    query: { organization_id: organizationId, project_id: projectId },
+  } as GetClassificationJobResultsApiV1ClassifierJobsClassifyJobIdResultsGetData;
+  const jobOptions =
+    jobData as Options<GetClassificationJobResultsApiV1ClassifierJobsClassifyJobIdResultsGetData>;
+  if (typeof client != "undefined") {
+    jobOptions.client = client;
+  }
+  let retries: number = 0;
+  while (true) {
+    if (retries > maxRetriesOnError) {
+      throw new Error(
+        "Error while getting the result of the classification job: Exceeded maximum number of retries, the API keeps returning errors.",
+      );
+    }
+    const response =
+      await getClassificationJobResultsApiV1ClassifierJobsClassifyJobIdResultsGet(
+        jobOptions,
+      );
+    if (!response.response.ok) {
+      if ("error" in response) {
+        console.log(
+          "An error occurred: ",
+          JSON.stringify(response.error),
+          "\nRetrying...",
+        );
+      }
+      retries++;
+      await sleep(retryInterval * 1000);
+    }
+    if (typeof response.data != "undefined") {
+      return response.data as ClassifyJobResults;
+    } else {
+      throw new Error(
+        "Error while retrieving results for the classify job: the result was successfully obtained but no data were returned",
+      );
+    }
+  }
+}
+
+export async function classify(
+  rules: ClassifierRule[],
+  parsingConfiguration: ClassifyParsingConfiguration,
+  fileContents:
+    | Buffer<ArrayBufferLike>[]
+    | File[]
+    | Uint8Array<ArrayBuffer>[]
+    | string[]
+    | undefined = undefined,
+  filePaths: string[] | undefined = undefined,
+  projectId: string | null = null,
+  organizationId: string | null = null,
+  client: Client | undefined = undefined,
+  pollingInterval: number = 1,
+  maxPollingIterations: number = 1800,
+  maxRetriesOnError: number = 10,
+  retryInterval: number = 0.5,
+): Promise<ClassifyJobResults> {
+  const fileIds: string[] = [];
+  if (!filePaths && !fileContents) {
+    throw new Error(
+      "One between filePath and fileContent needs to be provided",
+    );
+  }
+
+  if (filePaths) {
+    const uploadPromises = filePaths.map(async (name) => {
+      try {
+        const fileId = await uploadFile(
+          name,
+          undefined,
+          undefined,
+          projectId,
+          organizationId,
+          client,
+          maxRetriesOnError,
+          retryInterval,
+        );
+        if (fileId) {
+          return fileId;
+        } else {
+          console.error(`Unable to upload ${name}, skipping...`);
+          return null;
+        }
+      } catch (error) {
+        console.error(`Error uploading ${name}:`, error);
+        return null;
+      }
+    });
+
+    const results = await Promise.all(uploadPromises);
+    fileIds.push(...results.filter((id) => id !== null));
+  }
+
+  if (fileContents) {
+    const uploadPromises = fileContents.map(async (content) => {
+      try {
+        const fileId = await uploadFile(
+          undefined,
+          content,
+          undefined,
+          projectId,
+          organizationId,
+          client,
+          maxRetriesOnError,
+          retryInterval,
+        );
+        if (fileId) {
+          return fileId;
+        } else {
+          console.error(`Unable to upload file (content), skipping...`);
+          return null;
+        }
+      } catch (error) {
+        console.error(`Error uploading file (content):`, error);
+        return null;
+      }
+    });
+
+    const results = await Promise.all(uploadPromises);
+    fileIds.push(...results.filter((id) => id !== null));
+  }
+
+  if (fileIds.length == 0) {
+    throw new Error(
+      "None of the provided files was successfully uploaded, it is not possible to create a classification job.",
+    );
+  }
+
+  const jobId = await createClassifyJob(
+    fileIds,
+    rules,
+    parsingConfiguration,
+    organizationId,
+    projectId,
+    client,
+    maxRetriesOnError,
+    retryInterval,
+  );
+  const success = await pollForJobCompletion(
+    jobId,
+    pollingInterval,
+    maxPollingIterations,
+    client,
+  );
+  if (!success) {
+    throw new Error("Your job is taking longer than 10 minutes, timing out...");
+  } else {
+    return (await getJobResult(
+      jobId,
+      client,
+      projectId,
+      organizationId,
+      maxRetriesOnError,
+      retryInterval,
+    )) as ClassifyJobResults;
+  }
+}
+
+export {
+  type ClassifierRule,
+  type ClassifyJobResults,
+  type ClassifyParsingConfiguration,
+};

ts/llama_cloud_services/src/extract.ts

@@ -1,9 +1,5 @@
 import { emitWarning } from "process";
-import fs from "fs/promises";
-import { Blob } from "buffer";
-import * as path from "path";
 import type { ExtractResult } from "./type";
-import { randomUUID } from "@llamaindex/env";
 import { File } from "buffer";
 import {
   type Options,
@@ -19,7 +15,6 @@ import {
   type GetJobApiV1ExtractionJobsJobIdGetData,
   type GetJobResultApiV1ExtractionJobsJobIdResultGetData,
   StatusEnum,
-  type UploadFileApiV1FilesPostData,
   type StatelessExtractionRequest,
   type ExtractStatelessApiV1ExtractionRunPostData,
   type DeleteExtractionAgentApiV1ExtractionExtractionAgentsExtractionAgentIdDeleteData,
@@ -29,17 +24,12 @@ import {
   runJobApiV1ExtractionJobsPost,
   getJobApiV1ExtractionJobsJobIdGet,
   getJobResultApiV1ExtractionJobsJobIdResultGet,
-  uploadFileApiV1FilesPost,
   extractStatelessApiV1ExtractionRunPost,
   deleteExtractionAgentApiV1ExtractionExtractionAgentsExtractionAgentIdDelete,
 } from "./api";
 import type { Client } from "@hey-api/client-fetch";
 import { sleep } from "./utils";
-import { fileTypeFromBuffer } from "file-type";
-
-type BodyUploadFileApiV1FilesPost = {
-  upload_file: Blob | File;
-};
+import { uploadFile } from "./fileUpload";
 
 export async function createAgent(
   name: string,
@@ -221,95 +211,6 @@ export async function getAgent(
   }
 }
 
-function textToFile(text: string, fileName: string | null = null) {
-  return new File(
-    [text],
-    fileName ?? "uploadedFile_" + randomUUID().replaceAll("-", "_") + ".txt",
-  );
-}
-
-async function uploadFile(
-  filePath: string | undefined = undefined,
-  fileContent:
-    | Buffer<ArrayBufferLike>
-    | File
-    | Uint8Array<ArrayBuffer>
-    | string
-    | undefined = undefined,
-  fileName: string | undefined = undefined,
-  project_id: string | null = null,
-  organization_id: string | null = null,
-  client: Client | undefined = undefined,
-  maxRetriesOnError: number = 10,
-  retryInterval: number = 0.5,
-): Promise<string | undefined> {
-  let file: File | undefined = undefined;
-  if (typeof filePath === "undefined" && typeof fileContent === "undefined") {
-    throw new Error(
-      "One between filePath and fileContent needs to be provided",
-    );
-  } else if (typeof filePath != "undefined") {
-    const buffer = await fs.readFile(filePath);
-    const actualFileName = fileName ?? path.basename(filePath);
-    const uint8Array = new Uint8Array(buffer);
-    file = new File([uint8Array], actualFileName);
-  } else if (typeof fileContent != "undefined") {
-    if (fileContent instanceof File) {
-      file = fileContent;
-    } else if (fileContent instanceof Buffer) {
-      const fileType = await fileTypeFromBuffer(fileContent);
-      const ext = fileType?.ext ?? "pdf";
-      const uint8Array = new Uint8Array(fileContent);
-      file = new File(
-        [uint8Array],
-        fileName ??
-          "uploadedFile_" + randomUUID().replaceAll("-", "_") + "." + ext,
-      );
-    } else if (fileContent instanceof Uint8Array) {
-      const fileType = await fileTypeFromBuffer(fileContent);
-      const ext = fileType?.ext ?? "pdf";
-      file = new File(
-        [fileContent],
-        fileName ??
-          "uploadedFile_" + randomUUID().replaceAll("-", "_") + "." + ext,
-      );
-    } else if (typeof fileContent === "string") {
-      file = textToFile(fileContent, fileName);
-    } else {
-      throw new Error("Unsupported fileContent type");
-    }
-  }
-  const fileToUpload = {
-    upload_file: file,
-  } as BodyUploadFileApiV1FilesPost;
-  const uploadData = {
-    body: fileToUpload,
-    query: { organization_id: organization_id, project_id: project_id },
-  } as UploadFileApiV1FilesPostData;
-  const uploadOptions = uploadData as Options<UploadFileApiV1FilesPostData>;
-  if (typeof client != "undefined") {
-    uploadOptions.client = client;
-  }
-  let retries: number = 0;
-  while (true) {
-    if (retries > maxRetriesOnError) {
-      throw new Error(
-        "Error while processing your file: Exceeded maximum number of retries, the API keeps returning errors.",
-      );
-    }
-    const uploadResponse = await uploadFileApiV1FilesPost(uploadOptions);
-    let fileId: string | undefined = undefined;
-    if (!uploadResponse.response.ok) {
-      retries++;
-      await sleep(retryInterval * 1000);
-    }
-    if (typeof uploadResponse.data != "undefined") {
-      fileId = uploadResponse.data.id as string;
-      return fileId;
-    }
-  }
-}
-
 async function createExtractJob(
   options:
     | Options<RunJobApiV1ExtractionJobsPostData>

ts/llama_cloud_services/src/fileUpload.ts

@@ -0,0 +1,109 @@
+import fs from "fs/promises";
+import { Blob } from "buffer";
+import * as path from "path";
+import { randomUUID } from "@llamaindex/env";
+import { File } from "buffer";
+import {
+  type Options,
+  type UploadFileApiV1FilesPostData,
+  uploadFileApiV1FilesPost,
+} from "./api";
+import type { Client } from "@hey-api/client-fetch";
+import { sleep } from "./utils";
+import { fileTypeFromBuffer } from "file-type";
+
+type BodyUploadFileApiV1FilesPost = {
+  upload_file: Blob | File;
+};
+
+function textToFile(text: string, fileName: string | null = null) {
+  return new File(
+    [text],
+    fileName ?? "uploadedFile_" + randomUUID().replaceAll("-", "_") + ".txt",
+  );
+}
+
+export async function uploadFile(
+  filePath: string | undefined = undefined,
+  fileContent:
+    | Buffer<ArrayBufferLike>
+    | File
+    | Uint8Array<ArrayBuffer>
+    | string
+    | undefined = undefined,
+  fileName: string | undefined = undefined,
+  project_id: string | null = null,
+  organization_id: string | null = null,
+  client: Client | undefined = undefined,
+  maxRetriesOnError: number = 10,
+  retryInterval: number = 0.5,
+): Promise<string | undefined> {
+  let file: File | undefined = undefined;
+  if (typeof filePath === "undefined" && typeof fileContent === "undefined") {
+    throw new Error(
+      "One between filePath and fileContent needs to be provided",
+    );
+  } else if (typeof filePath != "undefined") {
+    const buffer = await fs.readFile(filePath);
+    const actualFileName = fileName ?? path.basename(filePath);
+    const uint8Array = new Uint8Array(buffer);
+    file = new File([uint8Array], actualFileName);
+  } else if (typeof fileContent != "undefined") {
+    if (fileContent instanceof File) {
+      file = fileContent;
+    } else if (fileContent instanceof Buffer) {
+      const fileType = await fileTypeFromBuffer(fileContent);
+      const ext = fileType?.ext ?? "pdf";
+      const uint8Array = new Uint8Array(fileContent);
+      file = new File(
+        [uint8Array],
+        fileName ??
+          "uploadedFile_" + randomUUID().replaceAll("-", "_") + "." + ext,
+      );
+    } else if (fileContent instanceof Uint8Array) {
+      const fileType = await fileTypeFromBuffer(fileContent);
+      const ext = fileType?.ext ?? "pdf";
+      file = new File(
+        [fileContent],
+        fileName ??
+          "uploadedFile_" + randomUUID().replaceAll("-", "_") + "." + ext,
+      );
+    } else if (typeof fileContent === "string") {
+      file = textToFile(fileContent, fileName);
+    } else {
+      throw new Error("Unsupported fileContent type");
+    }
+  }
+  const fileToUpload = {
+    upload_file: file,
+  } as BodyUploadFileApiV1FilesPost;
+  const uploadData = {
+    body: fileToUpload,
+    query: { organization_id: organization_id, project_id: project_id },
+  } as UploadFileApiV1FilesPostData;
+  const uploadOptions = uploadData as Options<UploadFileApiV1FilesPostData>;
+  if (typeof client != "undefined") {
+    uploadOptions.client = client;
+  }
+  let retries: number = 0;
+  while (true) {
+    if (retries > maxRetriesOnError) {
+      throw new Error(
+        "Error while processing your file: Exceeded maximum number of retries, the API keeps returning errors.",
+      );
+    }
+    const uploadResponse = await uploadFileApiV1FilesPost(uploadOptions);
+    let fileId: string | undefined = undefined;
+    if (!uploadResponse.response.ok) {
+      retries++;
+      await sleep(retryInterval * 1000);
+    }
+    if (
+      uploadResponse.response.ok &&
+      typeof uploadResponse.data != "undefined"
+    ) {
+      fileId = uploadResponse.data.id as string;
+      return fileId;
+    }
+  }
+}

ts/llama_cloud_services/src/index.ts

@@ -8,3 +8,9 @@ export type { CloudConstructorParams } from "./type.js";
 export { LlamaParseReader } from "./reader.js";
 export { LlamaExtract, LlamaExtractAgent } from "./LlamaExtract.js";
 export type { ExtractConfig } from "./extract.js";
+export { LlamaClassify } from "./LlamaClassify.js";
+export type {
+  ClassifierRule,
+  ClassifyJobResults,
+  ClassifyParsingConfiguration,
+} from "./classify.js";

ts/llama_cloud_services/src/utils.ts

@@ -117,3 +117,25 @@ export function getSavePath(downloadPath: string, i: number): string {
 
   return savePath;
 }
+
+const URLS = {
+  us: "https://api.cloud.llamaindex.ai",
+  eu: "https://api.cloud.eu.llamaindex.ai",
+  "us-staging": "https://api.staging.llamaindex.ai",
+} as const;
+
+export function getUrl(
+  baseUrl: string | undefined,
+  region: string | undefined,
+) {
+  if (typeof baseUrl != "undefined") {
+    return baseUrl;
+  }
+  if (typeof region === "undefined") {
+    return URLS["us"];
+  } else if (region === "us" || region === "eu" || region === "us-staging") {
+    return URLS[region];
+  } else {
+    throw new Error(`Unsupported region: ${region}`);
+  }
+}

ts/llama_cloud_services/tests/integration.test.ts

@@ -2,6 +2,8 @@ import { describe, it, expect, beforeEach, beforeAll } from "vitest";
 import { LlamaParseReader } from "../src/reader.js";
 import { LlamaCloudIndex } from "../src/LlamaCloudIndex.js";
 import { LlamaExtract, LlamaExtractAgent } from "../src/LlamaExtract.js";
+import { LlamaClassify } from "../src/LlamaClassify.js";
+import { ClassifierRule, ClassifyParsingConfiguration } from "../src/classify.js";
 import { Document } from "@llamaindex/core/schema";
 import { fs } from "@llamaindex/env";
 import { ExtractConfig } from "../src/api.js";
@@ -489,6 +491,59 @@ describe("Integration Tests", () => {
     );
   });
 
+  describe("LlamaClassify Integration", () => {
+    it.skipIf(skipIfNoApiKey)(
+      "should classify data correctly (file paths and file contents) ",
+      async () => {
+        const classifyClient = new LlamaClassify(
+          process.env.LLAMA_CLOUD_API_KEY!,
+          "https://api.cloud.llamaindex.ai",
+        );
+        const testContent =
+          `A Fox one day spied a beautiful bunch of ripe grapes hanging from a vine trained along the branches of a tree. The grapes seemed ready to burst with juice, and the Fox's mouth watered as he gazed longingly at them. The bunch hung from a high branch, and the Fox had to jump for it. The first time he jumped he missed it by a long way. So he walked off a short distance and took a running leap at it, only to fall short once more. Again and again he tried, but in vain. Now he sat down and looked at the grapes in disgust. "What a fool I am," he said. "Here I am wearing myself out to get a bunch of sour grapes that are not worth gaping for." And off he walked very, very scornfully.There are many who pretend to despise and belittle that which is beyond their reach.`;
+        const testFilePath = "the_fox_and_the_grapes.md";
+
+        await fs.writeFile(testFilePath, new TextEncoder().encode(testContent));
+
+        const rules: ClassifierRule[] = [
+          {type: "fable", description: "A short story featuring animals whose aim is to teach the reader a lesson (the moral of the story)"},
+          {type: "fairy_tale", description: "A mid-to-long story featuring humans, magic creatures and other characters, whose main aim is to entertain the readers."}
+        ]
+
+        const parsingConfig: ClassifyParsingConfiguration = {lang: "en"}
+
+        const result = await classifyClient.classify(
+          rules,
+          parsingConfig,
+          undefined,
+          ["the_fox_and_the_grapes.md"]
+        );
+        expect("items" in result).toBeTruthy();
+        expect(result.items.length).toBeGreaterThan(0);
+        expect("result" in result.items[0]).toBeTruthy();
+        expect(result.items[0].result!.type === "fable").toBeTruthy();
+
+        const buffer = await fs.readFile("the_fox_and_the_grapes.md");
+        const resultBuffer = await classifyClient.classify(
+          rules,
+          parsingConfig,
+          [buffer],
+        );
+        expect("items" in resultBuffer).toBeTruthy();
+        expect(resultBuffer.items.length).toBeGreaterThan(0);
+        expect("result" in resultBuffer.items[0]).toBeTruthy();
+        expect(resultBuffer.items[0].result!.type === "fable").toBeTruthy();
+
+        try {
+          await fs.unlink("the_fox_and_the_grapes.md")
+        } catch(err) {
+          console.log(`Unable to delete file the_fox_and_the_grapes.md because of ${err}`)
+        }
+      },
+      60000,
+    );
+  });
+
   describe("LlamaExtract Integration", () => {
     it.skipIf(skipIfNoApiKey)(
       "should create agents correctly",