cr

* wip

* newline

* wip

* docs

.github/workflows/build_package.yml

@@ -45,4 +45,4 @@ jobs:
       - name: Test import
         shell: bash
         working-directory: ${{ vars.RUNNER_TEMP }}
-        run: python -c "import llama_parse"
+        run: python -c "import llama_cloud_services"

.github/workflows/publish_release.yml

@@ -14,7 +14,7 @@ env:
 jobs:
   build-n-publish:
     name: Build and publish to PyPI
-    if: github.repository == 'run-llama/llama_parse'
+    if: github.repository == 'run-llama/llama_cloud_services'
     runs-on: ubuntu-latest
 
     steps:
@@ -23,18 +23,28 @@ jobs:
         uses: actions/setup-python@v4
         with:
           python-version: ${{ env.PYTHON_VERSION }}
+
       - name: Install Poetry
         uses: snok/install-poetry@v1
         with:
           version: ${{ env.POETRY_VERSION }}
+
       - name: Install deps
         shell: bash
         run: pip install -e .
-      - name: Build and publish to pypi
-        uses: JRubics/poetry-publish@v1.17
+
+      - name: Build and publish llama-cloud-services
+        uses: JRubics/poetry-publish@v2.1
         with:
           pypi_token: ${{ secrets.LLAMA_PARSE_PYPI_TOKEN }}
-          ignore_dev_requirements: "yes"
+          poetry_install_options: "--without dev"
+
+      - name: Build and publish llama-parse
+        uses: JRubics/poetry-publish@v2.1
+        with:
+          working_directory: "llama_parse"
+          pypi_token: ${{ secrets.LLAMA_PARSE_PYPI_TOKEN }}
+          poetry_install_options: "--without dev"
 
       - name: Create GitHub Release
         id: create_release
@@ -52,6 +62,7 @@ jobs:
           export PKG=$(ls dist/ | grep tar)
           set -- $PKG
           echo "name=$1" >> $GITHUB_ENV
+
       - name: Upload Release Asset (sdist) to GitHub
         id: upload-release-asset
         uses: actions/upload-release-asset@v1

.github/workflows/unit_test.yml

@@ -17,7 +17,7 @@ jobs:
       # You can use PyPy versions in python-version.
       # For example, pypy-2.7 and pypy-3.8
       matrix:
-        python-version: ["3.8", "3.10", "3.11"]
+        python-version: ["3.9", "3.10", "3.11", "3.12"]
     steps:
       - uses: actions/checkout@v3
         with:

.gitignore

@@ -3,3 +3,5 @@ __pycache__/
 *.pyc
 .DS_Store
 .idea
+.env*
+.ipynb_checkpoints*

.pre-commit-config.yaml

@@ -33,6 +33,7 @@ repos:
     rev: v1.0.1
     hooks:
       - id: mypy
+        exclude: ^tests/
         additional_dependencies:
           [
             "types-requests",
@@ -46,7 +47,7 @@ repos:
           [
             --disallow-untyped-defs,
             --ignore-missing-imports,
-            --python-version=3.8,
+            --python-version=3.10,
           ]
   - repo: https://github.com/adamchainz/blacken-docs
     rev: 1.16.0

README.md

@@ -1,158 +1,65 @@
-# LlamaParse
-
-[![PyPI - Downloads](https://img.shields.io/pypi/dm/llama-parse)](https://pypi.org/project/llama-parse/)
-[![GitHub contributors](https://img.shields.io/github/contributors/run-llama/llama_parse)](https://github.com/run-llama/llama_parse/graphs/contributors)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/llama-cloud-services)](https://pypi.org/project/llama-cloud-services/)
+[![GitHub contributors](https://img.shields.io/github/contributors/run-llama/llama_cloud_services)](https://github.com/run-llama/llama_cloud_services/graphs/contributors)
 [![Discord](https://img.shields.io/discord/1059199217496772688)](https://discord.gg/dGcwcsnxhU)
 
-LlamaParse is a **GenAI-native document parser** that can parse complex document data for any downstream LLM use case (RAG, agents).
+# Llama Cloud Services
 
-It is really good at the following:
+This repository contains the code for hand-written SDKs and clients for interacting with LlamaCloud.
 
-- ✅ **Broad file type support**: Parsing a variety of unstructured file types (.pdf, .pptx, .docx, .xlsx, .html) with text, tables, visual elements, weird layouts, and more.
-- ✅ **Table recognition**: Parsing embedded tables accurately into text and semi-structured representations.
-- ✅ **Multimodal parsing and chunking**: Extracting visual elements (images/diagrams) into structured formats and return image chunks using the latest multimodal models.
-- ✅ **Custom parsing**: Input custom prompt instructions to customize the output the way you want it.
+This includes:
 
-LlamaParse directly integrates with [LlamaIndex](https://github.com/run-llama/llama_index).
-
-The free plan is up to 1000 pages a day. Paid plan is free 7k pages per week + 0.3c per additional page by default. There is a sandbox available to test the API [**https://cloud.llamaindex.ai/parse ↗**](https://cloud.llamaindex.ai/parse).
-
-Read below for some quickstart information, or see the [full documentation](https://docs.cloud.llamaindex.ai/).
-
-If you're a company interested in enterprise RAG solutions, and/or high volume/on-prem usage of LlamaParse, come [talk to us](https://www.llamaindex.ai/contact).
+- [LlamaParse](./parse.md) - A GenAI-native document parser that can parse complex document data for any downstream LLM use case (Agents, RAG, data processing, etc.).
+- [LlamaReport (beta/invite-only)](./report.md) - A prebuilt agentic report builder that can be used to build reports from a variety of data sources.
+- [LlamaExtract (beta/invite-only)](./extract.md) - A prebuilt agentic data extractor that can be used to transform data into a structured JSON representation.
 
 ## Getting Started
 
-First, login and get an api-key from [**https://cloud.llamaindex.ai/api-key ↗**](https://cloud.llamaindex.ai/api-key).
-
-Then, make sure you have the latest LlamaIndex version installed.
-
-**NOTE:** If you are upgrading from v0.9.X, we recommend following our [migration guide](https://pretty-sodium-5e0.notion.site/v0-10-0-Migration-Guide-6ede431dcb8841b09ea171e7f133bd77), as well as uninstalling your previous version first.
-
-```
-pip uninstall llama-index  # run this if upgrading from v0.9.x or older
-pip install -U llama-index --upgrade --no-cache-dir --force-reinstall
-```
-
-Lastly, install the package:
-
-`pip install llama-parse`
-
-Now you can parse your first PDF file using the command line interface. Use the command `llama-parse [file_paths]`. See the help text with `llama-parse --help`.
+Install the package:
 
 ```bash
-export LLAMA_CLOUD_API_KEY='llx-...'
-
-# output as text
-llama-parse my_file.pdf --result-type text --output-file output.txt
-
-# output as markdown
-llama-parse my_file.pdf --result-type markdown --output-file output.md
-
-# output as raw json
-llama-parse my_file.pdf --output-raw-json --output-file output.json
+pip install llama-cloud-services
 ```
 
-You can also create simple scripts:
+Then, get your API key from [LlamaCloud](https://cloud.llamaindex.ai/).
+
+Then, you can use the services in your code:
 
 ```python
-import nest_asyncio
+from llama_cloud_services import LlamaParse, LlamaReport, LlamaExtract
 
-nest_asyncio.apply()
-
-from llama_parse import LlamaParse
-
-parser = LlamaParse(
-    api_key="llx-...",  # can also be set in your env as LLAMA_CLOUD_API_KEY
-    result_type="markdown",  # "markdown" and "text" are available
-    num_workers=4,  # if multiple files passed, split in `num_workers` API calls
-    verbose=True,
-    language="en",  # Optionally you can define a language, default=en
-)
-
-# sync
-documents = parser.load_data("./my_file.pdf")
-
-# sync batch
-documents = parser.load_data(["./my_file1.pdf", "./my_file2.pdf"])
-
-# async
-documents = await parser.aload_data("./my_file.pdf")
-
-# async batch
-documents = await parser.aload_data(["./my_file1.pdf", "./my_file2.pdf"])
+parser = LlamaParse(api_key="YOUR_API_KEY")
+report = LlamaReport(api_key="YOUR_API_KEY")
+extract = LlamaExtract(api_key="YOUR_API_KEY")
 ```
 
-## Using with file object
+See the quickstart guides for each service for more information:
 
-You can parse a file object directly:
+- [LlamaParse](./parse.md)
+- [LlamaReport (beta/invite-only)](./report.md)
+- [LlamaExtract (beta/invite-only)](./extract.md)
+
+## Switch to EU SaaS 🇪🇺
+
+If you are interested in using LlamaCloud services in the EU, you can adjust your base URL to `https://api.cloud.eu.llamaindex.ai`.
+
+You can also create your API key in the EU region [here](https://cloud.eu.llamaindex.ai).
 
 ```python
-import nest_asyncio
-
-nest_asyncio.apply()
-
-from llama_parse import LlamaParse
-
-parser = LlamaParse(
-    api_key="llx-...",  # can also be set in your env as LLAMA_CLOUD_API_KEY
-    result_type="markdown",  # "markdown" and "text" are available
-    num_workers=4,  # if multiple files passed, split in `num_workers` API calls
-    verbose=True,
-    language="en",  # Optionally you can define a language, default=en
+from llama_cloud_services import (
+    LlamaParse,
+    LlamaReport,
+    LlamaExtract,
+    EU_BASE_URL,
 )
 
-file_name = "my_file1.pdf"
-extra_info = {"file_name": file_name}
-
-with open(f"./{file_name}", "rb") as f:
-    # must provide extra_info with file_name key with passing file object
-    documents = parser.load_data(f, extra_info=extra_info)
-
-# you can also pass file bytes directly
-with open(f"./{file_name}", "rb") as f:
-    file_bytes = f.read()
-    # must provide extra_info with file_name key with passing file bytes
-    documents = parser.load_data(file_bytes, extra_info=extra_info)
+parser = LlamaParse(api_key="YOUR_API_KEY", base_url=EU_BASE_URL)
+report = LlamaReport(api_key="YOUR_API_KEY", base_url=EU_BASE_URL)
+extract = LlamaExtract(api_key="YOUR_API_KEY", base_url=EU_BASE_URL)
 ```
 
-## Using with `SimpleDirectoryReader`
-
-You can also integrate the parser as the default PDF loader in `SimpleDirectoryReader`:
-
-```python
-import nest_asyncio
-
-nest_asyncio.apply()
-
-from llama_parse import LlamaParse
-from llama_index.core import SimpleDirectoryReader
-
-parser = LlamaParse(
-    api_key="llx-...",  # can also be set in your env as LLAMA_CLOUD_API_KEY
-    result_type="markdown",  # "markdown" and "text" are available
-    verbose=True,
-)
-
-file_extractor = {".pdf": parser}
-documents = SimpleDirectoryReader(
-    "./data", file_extractor=file_extractor
-).load_data()
-```
-
-Full documentation for `SimpleDirectoryReader` can be found on the [LlamaIndex Documentation](https://docs.llamaindex.ai/en/stable/module_guides/loading/simpledirectoryreader.html).
-
-## Examples
-
-Several end-to-end indexing examples can be found in the examples folder
-
-- [Getting Started](examples/demo_basic.ipynb)
-- [Advanced RAG Example](examples/demo_advanced.ipynb)
-- [Raw API Usage](examples/demo_api.ipynb)
-
 ## Documentation
 
-[https://docs.cloud.llamaindex.ai/](https://docs.cloud.llamaindex.ai/)
+You can see complete SDK and API documentation for each service on [our official docs](https://docs.cloud.llamaindex.ai/).
 
 ## Terms of Service
 
@@ -160,6 +67,4 @@ See the [Terms of Service Here](./TOS.pdf).
 
 ## Get in Touch (LlamaCloud)
 
-LlamaParse is part of LlamaCloud, our e2e enterprise RAG platform that provides out-of-the-box, production-ready connectors, indexing, and retrieval over your complex data sources. We offer SaaS and VPC options.
-
-LlamaCloud is currently available via waitlist (join by [creating an account](https://cloud.llamaindex.ai/)). If you're interested in state-of-the-art quality and in centralizing your RAG efforts, come [get in touch with us](https://www.llamaindex.ai/contact).
+You can get in touch with us by following our [contact link](https://www.llamaindex.ai/contact).

examples/demo_starter_multimodal.ipynb

@@ -1,415 +0,0 @@
-{
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "id": "97c79c38-38a3-40f3-ba2e-250649347d63",
-      "metadata": {
-        "id": "97c79c38-38a3-40f3-ba2e-250649347d63"
-      },
-      "source": [
-        "<a href=\"https://colab.research.google.com/github/run-llama/llama_parse/blob/main/examples/demo_starter_multimodal.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "4e081457",
-      "metadata": {},
-      "source": [
-        "# Multimodal Parsing using LlamaParse\n",
-        "\n",
-        "This cookbook shows you how to use LlamaParse to parse any document with the multimodal capabilities of Multi-Modal LLMs from Anthropic/ OpenAI.\n",
-        "\n",
-        "LlamaParse allows you to plug in external, multimodal model vendors for parsing - we handle the error correction, validation, and scalability/reliability for you.\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "qOdqBxCS51Ow",
-      "metadata": {
-        "id": "qOdqBxCS51Ow"
-      },
-      "source": [
-        "### Installation"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "H_Vqcylb50vm",
-      "metadata": {
-        "id": "H_Vqcylb50vm"
-      },
-      "outputs": [],
-      "source": [
-        "!pip install llama-parse"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "15e60ecf-519c-41fc-911b-765adaf8bad4",
-      "metadata": {
-        "id": "15e60ecf-519c-41fc-911b-765adaf8bad4"
-      },
-      "source": [
-        "### Setup\n",
-        "\n",
-        "Here we setup `LLAMA_CLOUD_API_KEY` for using `LlamaParse`."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 1,
-      "id": "91a9e532-1454-40e0-bbf0-fd442c350121",
-      "metadata": {
-        "id": "91a9e532-1454-40e0-bbf0-fd442c350121"
-      },
-      "outputs": [],
-      "source": [
-        "import nest_asyncio\n",
-        "\n",
-        "nest_asyncio.apply()\n",
-        "\n",
-        "import os\n",
-        "\n",
-        "# API access to llama-cloud\n",
-        "os.environ[\"LLAMA_CLOUD_API_KEY\"] = \"<YOUR LLAMACLOUD API KEY>\""
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "LGwBNPNotZRQ",
-      "metadata": {
-        "id": "LGwBNPNotZRQ"
-      },
-      "source": [
-        "## Download Data\n",
-        "\n",
-        "For this demonstration, we will use OpenAI's recent paper `Evaluation of OpenAI o1: Opportunities and Challenges of AGI`."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 2,
-      "id": "IjtKDQRLrylI",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "IjtKDQRLrylI",
-        "outputId": "31df0fac-51f2-4697-f78b-0b7c0b8cd145"
-      },
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "--2024-12-05 18:54:24--  https://arxiv.org/pdf/2409.18486\n",
-            "Resolving arxiv.org (arxiv.org)... 151.101.67.42, 151.101.131.42, 151.101.3.42, ...\n",
-            "Connecting to arxiv.org (arxiv.org)|151.101.67.42|:443... connected.\n",
-            "HTTP request sent, awaiting response... 200 OK\n",
-            "Length: 13986265 (13M) [application/pdf]\n",
-            "Saving to: ‘o1.pdf’\n",
-            "\n",
-            "o1.pdf              100%[===================>]  13.34M  11.8MB/s    in 1.1s    \n",
-            "\n",
-            "2024-12-05 18:54:26 (11.8 MB/s) - ‘o1.pdf’ saved [13986265/13986265]\n",
-            "\n"
-          ]
-        }
-      ],
-      "source": [
-        "!wget \"https://arxiv.org/pdf/2409.18486\" -O \"o1.pdf\""
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "4e29a9d7-5bd9-4fb8-8ec1-4c128a748662",
-      "metadata": {
-        "id": "4e29a9d7-5bd9-4fb8-8ec1-4c128a748662"
-      },
-      "source": [
-        "## Initialize LlamaParse\n",
-        "\n",
-        "Initialize LlamaParse in multimodal mode, and specify the vendor.\n",
-        "\n",
-        "**NOTE**: optionally you can specify the Anthropic/ OpenAI API key. If you choose to do so LlamaParse will only charge you 1 credit (0.3c) per page. \n",
-        "\n",
-        "\n",
-        "Using your own API key may incur additional costs from your model provider and could result in failed pages or documents if you do not have sufficient usage limits."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 3,
-      "id": "dc921729-3446-42ca-8e1b-a6fd26195ed9",
-      "metadata": {
-        "id": "dc921729-3446-42ca-8e1b-a6fd26195ed9"
-      },
-      "outputs": [],
-      "source": [
-        "from llama_index.core.schema import TextNode\n",
-        "from typing import List\n",
-        "\n",
-        "def get_text_nodes(json_list: List[dict]):\n",
-        "    text_nodes = []\n",
-        "    for idx, page in enumerate(json_list):\n",
-        "        text_node = TextNode(text=page[\"md\"], metadata={\"page\": page[\"page\"]})\n",
-        "        text_nodes.append(text_node)\n",
-        "    return text_nodes"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "1b5d6da6",
-      "metadata": {},
-      "source": [
-        "### With anthropic-sonnet-3.5"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 5,
-      "id": "f2e9d9cf-8189-4fcb-b34f-cde6cc0b59c8",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "f2e9d9cf-8189-4fcb-b34f-cde6cc0b59c8",
-        "outputId": "a337cbdd-60db-4a73-b66b-2bd6159e81f2"
-      },
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Started parsing the file under job_id dd9d5e0f-160e-486a-89a2-6005e5a1c2ac\n"
-          ]
-        }
-      ],
-      "source": [
-        "from llama_parse import LlamaParse\n",
-        "\n",
-        "parser = LlamaParse(\n",
-        "    result_type=\"markdown\",\n",
-        "    use_vendor_multimodal_model=True,\n",
-        "    vendor_multimodal_model_name=\"anthropic-sonnet-3.5\",\n",
-        "    target_pages=\"24\"\n",
-        "    # invalidate_cache=True\n",
-        ")\n",
-        "json_objs = parser.get_json_result(\"o1.pdf\")\n",
-        "json_list = json_objs[0][\"pages\"]\n",
-        "docs = get_text_nodes(json_list)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "4f3c51b0-7878-48d7-9bc3-02b516500128",
-      "metadata": {
-        "id": "4f3c51b0-7878-48d7-9bc3-02b516500128"
-      },
-      "source": [
-        "### With GPT-4o\n",
-        "\n",
-        "For comparison, we will also parse the document using GPT-4o."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 6,
-      "id": "6fc3f258-50ae-4988-b904-c105463a498f",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "6fc3f258-50ae-4988-b904-c105463a498f",
-        "outputId": "89c525c4-2b93-4909-9657-55646e034637"
-      },
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Started parsing the file under job_id 6a4dea44-4f90-406b-b290-9e98620b1232\n"
-          ]
-        }
-      ],
-      "source": [
-        "from llama_parse import LlamaParse\n",
-        "\n",
-        "parser_gpt4o = LlamaParse(\n",
-        "    result_type=\"markdown\",\n",
-        "    use_vendor_multimodal_model=True,\n",
-        "    vendor_multimodal_model=\"openai-gpt4o\",\n",
-        "    target_pages=\"24\",\n",
-        "    # invalidate_cache=True\n",
-        ")\n",
-        "json_objs_gpt4o = parser_gpt4o.get_json_result(\"o1.pdf\")\n",
-        "json_list_gpt4o = json_objs_gpt4o[0][\"pages\"]\n",
-        "docs_gpt4o = get_text_nodes(json_list_gpt4o)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "44c20f7a-2901-4dd0-b635-a4b33c5664c1",
-      "metadata": {
-        "id": "44c20f7a-2901-4dd0-b635-a4b33c5664c1"
-      },
-      "source": [
-        "### View Results\n",
-        "\n",
-        "Let's visualize the results along with the original document page."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 7,
-      "id": "778698aa-da7e-4081-b3b5-0372f228536f",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "778698aa-da7e-4081-b3b5-0372f228536f",
-        "outputId": "bb89e323-7041-4fc3-d835-95e373189d02"
-      },
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "page: 25\n",
-            "\n",
-            "| Participant_ID | clinical Description Reference |\n",
-            "|-----------------|----------------------------------|\n",
-            "| Attribute | Value | Basic Personal Information: Subject 098_S_0896 is a 72.0-year-old Female who has completed 15 years of education. The ethnicity is Not Hisp/Latino and race is White. Marital status is Married. Initially diagnosed as AD, as of the date 2007-10-24, the final diagnosis was Dementia. |\n",
-            "| Age | 72.0 |\n",
-            "| Sex | Female |\n",
-            "| Education | 15 |\n",
-            "| Race | White | Biomarker Measurements: The subject's genetic profile includes an ApoE4 status of 0.0... |\n",
-            "| DX_bl | AD |\n",
-            "| DX | Dementia |\n",
-            "| ... | ... | Cognitive and Neurofunctional Assessments: The Mini-Mental State Examination score stands at 29.0. The Clinical Dementia Rating, sum of boxes, is 1.0. ADAS 11 and 13 scores are 4.67 and 4.67 respectively, with a score of 1.0 in delayed word recall... |\n",
-            "| APOE4 | 1.0 |\n",
-            "| TAU | 212.5 |\n",
-            "| ... | ... |\n",
-            "| MMSE | 29.0 | Volumetric Data: Under MRI conditions at a field strength of 1.5 Tesla MRI Tesla, using Cross Sectional FreeSurfer (FreeSurfer Version 4.3), the imaging data recorded includes ventricles volume at 54422.0, hippocampus volume at 6677.0, whole brain volume at 1147980.0, entorhinal cortex volume at 2782.0, fusiform gyrus volume at 19432.0, and middle temporal area volume at 24951.0. The intracranial volume measured is 1799580.0.... |\n",
-            "| CDRSB | 0.0 |\n",
-            "| ... | ... |\n",
-            "| FLDSTRENG | 1.5 Tesla MRI |\n",
-            "| Ventricles | 84599 |\n",
-            "| Hippocampus | 5319 |\n",
-            "| ... | ... |\n",
-            "\n",
-            "Figure 2: An example of a patient table and its corresponding clinical description.\n",
-            "\n",
-            "skills. Mathematics, as a highly structured and logic-driven discipline, provides an ideal testing ground for evaluating this reasoning ability. To investigate o1-preview's performance, we designed a series of tests covering various difficulty levels. We begin with high school-level math competition problems in this section, followed by college-level mathematics problems in the next section, allowing us to observe the model's logical reasoning across varying levels of complexity.\n",
-            "\n",
-            "In this section, we selected two primary areas of mathematics: algebra and counting and probability in this section. We chose these two topics because of their heavy reliance on problem-solving skills and their frequent use in assessing logical and abstract thinking [46]. The dataset used in testing is from the MATH dataset [46]. The problems in the dataset cover a wide range of subjects, including Prealgebra, Intermediate Algebra, Algebra, Geometry, Counting and Probability, Number Theory, and Precalculus. Each problem is categorized based on difficulty, ranked from level 1 to 5, according to the Art of Problem Solving (AoPS). The dataset mainly comprises problems from various high school math competitions, including the American Mathematics Competitions (AMC) 10 and 12, as well as the American Invitational Mathematics Examination (AIME), and other similar contests. Each problem comes with detailed reference solutions, allowing for a comprehensive comparison of o1-preview's solutions.\n",
-            "\n",
-            "In addition to evaluating the final answers produced by o1-preview, our analysis delves into the step-by-step reasoning process of the o1-preview's solutions. By comparing o1-preview's solutions with the dataset's solutions, we assess its ability to engage in logical reasoning, handle abstract problem-solving tasks, and apply structured approaches to reach correct answers. This deeper analysis offers insights into o1-preview's overall reasoning capabilities, using mathematics as a reliable indicator for logical and structured thought processes.\n"
-          ]
-        }
-      ],
-      "source": [
-        "# using Sonnet-3.5\n",
-        "print(docs[0].get_content(metadata_mode=\"all\"))"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 8,
-      "id": "1511a30f-3efc-4142-9668-7dc056a24d0c",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "1511a30f-3efc-4142-9668-7dc056a24d0c",
-        "outputId": "2e5e8e20-2b41-4183-f21f-dff503a03089"
-      },
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "page: 25\n",
-            "\n",
-            "\n",
-            "| Participant_ID | clinical Description Reference |\n",
-            "|----------------|--------------------------------|\n",
-            "| **Attribute**  | **Value**                      |\n",
-            "| Age            | 72.0                           |\n",
-            "| Sex            | Female                         |\n",
-            "| Education      | 15                             |\n",
-            "| Race           | White                          |\n",
-            "| DX_bl          | AD                             |\n",
-            "| DX             | Dementia                       |\n",
-            "| ...            | ...                            |\n",
-            "| APOE4          | 1.0                            |\n",
-            "| TAU            | 212.5                          |\n",
-            "| ...            | ...                            |\n",
-            "| MMSE           | 29.0                           |\n",
-            "| CDRSB          | 0.0                            |\n",
-            "| ...            | ...                            |\n",
-            "| FLDSTRENG      | 1.5 Tesla MRI                  |\n",
-            "| Ventricles     | 84599                          |\n",
-            "| Hippocampus    | 5319                           |\n",
-            "| ...            | ...                            |\n",
-            "\n",
-            "**Basic Personal Information:** Subject 098_S_0896 is a 72.0-year-old Female who has completed 15 years of education. The ethnicity is Not Hisp/Latino and race is White. Marital status is Married. Initially diagnosed as AD, as of the date 2007-10-24, the final diagnosis was Dementia.\n",
-            "\n",
-            "**Biomarker Measurements:** The subject's genetic profile includes an ApoE4 status of 0.0...\n",
-            "\n",
-            "**Cognitive and Neurofunctional Assessments:** The Mini-Mental State Examination score stands at 29.0. The Clinical Dementia Rating, sum of boxes, is 1.0. ADAS 11 and 13 scores are 4.67 and 4.67 respectively, with a score of 1.0 in delayed word recall...\n",
-            "\n",
-            "**Volumetric Data:** Under MRI conditions at a field strength of 1.5 Tesla MRI Tesla, using Cross-Sectional FreeSurfer (FreeSurfer Version 4.3), the imaging data recorded includes ventricles volume at 84422.0, hippocampus volume at 6677.0, whole brain volume at 1147980.0, entorhinal cortex volume at 27820.0, fusiform gyrus volume at 19432.0, and middle temporal area volume at 24951.0. The intracranial volume measured is 1799580.0...\n",
-            "\n",
-            "Figure 2: An example of a patient table and its corresponding clinical description.\n",
-            "\n",
-            "----\n",
-            "\n",
-            "Skills. Mathematics, as a highly structured and logic-driven discipline, provides an ideal testing ground for evaluating this reasoning ability. To investigate o1-preview’s performance, we designed a series of tests covering various difficulty levels. We begin with high school-level math competition problems in this section, followed by college-level mathematics problems in the next section, allowing us to observe the model’s logical reasoning across varying levels of complexity.\n",
-            "\n",
-            "In this section, we selected two primary areas of mathematics: algebra and counting and probability in this section. We chose these two topics because of their heavy reliance on problem-solving skills and their frequent use in assessing logical and abstract thinking [46]. The dataset used in testing is from the MATH dataset [46]. The problems in the dataset cover a wide range of subjects, including Prealgebra, Intermediate Algebra, Algebra, Geometry, Counting and Probability, Number Theory, and Precalculus. Each problem is categorized based on difficulty, ranked from level 1 to 5, according to the Art of Problem Solving (AoPS). The dataset mainly comprises problems from various high school math competitions, including the American Mathematics Competitions (AMC) 10 and 12, as well as the American Invitational Mathematics Examination (AIME), and other similar contests. Each problem comes with detailed reference solutions, allowing for a comprehensive comparison of o1-preview’s solutions.\n",
-            "\n",
-            "In addition to evaluating the final answers produced by o1-preview, our analysis delves into the step-by-step reasoning process of the o1-preview’s solutions. By comparing o1-preview’s solutions with the dataset’s solutions, we assess its ability to engage in logical reasoning, handle abstract problem-solving tasks, and apply structured approaches to reach correct answers. This deeper analysis offers insights into o1-preview’s overall reasoning capabilities, using mathematics as a reliable indicator for logical and structured thought processes.\n"
-          ]
-        }
-      ],
-      "source": [
-        "# using GPT-4o\n",
-        "print(docs_gpt4o[0].get_content(metadata_mode=\"all\"))"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "1c75bb85",
-      "metadata": {},
-      "outputs": [],
-      "source": []
-    }
-  ],
-  "metadata": {
-    "colab": {
-      "provenance": []
-    },
-    "kernelspec": {
-      "display_name": "llamacloud",
-      "language": "python",
-      "name": "llamacloud"
-    },
-    "language_info": {
-      "codemirror_mode": {
-        "name": "ipython",
-        "version": 3
-      },
-      "file_extension": ".py",
-      "mimetype": "text/x-python",
-      "name": "python",
-      "nbconvert_exporter": "python",
-      "pygments_lexer": "ipython3",
-      "version": "3.12.4"
-    }
-  },
-  "nbformat": 4,
-  "nbformat_minor": 5
-}

examples/extract/lm317_structured_extraction.ipynb

@@ -0,0 +1,318 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "1f6bd03d-1b8b-45a0-bc2c-5a13f1a5d8d3",
+   "metadata": {},
+   "source": [
+    "# LM317 Voltage Regulator Datasheet Structured Extraction\n",
+    "\n",
+    "<a href=\"https://colab.research.google.com/github/run-llama/llama_cloud_services/blob/main/examples/extract/lm317_structured_extraction.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
+    "\n",
+    "This notebook demonstrates an agentic document workflow using LlamaExtract to process an LM317 voltage regulator datasheet. In this example, we define a structured extraction schema that converts key technical fields into standardized subfields. For instance, the output voltage is split into a minimum and maximum value with a defined unit, and we capture page citations for each extracted field.\n",
+    "\n",
+    "The target user is an electronics engineer at a component manufacturing company who needs to consolidate datasheet information into a standardized specification sheet for design and quality control.\n",
+    "\n",
+    "This approach reduces manual data entry, improves extraction accuracy and standardization, and provides traceability for each technical detail."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a3b8c8d5-ff3e-48ce-b0b8-29b6b1f517f8",
+   "metadata": {},
+   "source": [
+    "## Use Case Overview\n",
+    "\n",
+    "### Problem\n",
+    "Datasheets like that for the LM317 regulator are often distributed as PDFs containing multiple tables, charts, and complex textual descriptions. Engineers must manually extract technical details such as voltage ranges, dropout voltage, maximum current, input voltage range, and pin configurations. This process is error-prone and time-consuming.\n",
+    "\n",
+    "### Agent Workflow (Combination of Automation and Chat)\n",
+    "1. **Upload Datasheet:** The engineer uploads the LM317 datasheet PDF.  \n",
+    "2. **Structured Extraction:** An automated agent processes the PDF and extracts key technical details into structured fields (e.g., output voltage as a range with separate min/max values).\n",
+    "3. **Interactive Verification:** The engineer can query the agent (via chat) for further details or clarification (e.g., \"Show me the detailed pin configuration extraction\") and review the cited pages.\n",
+    "\n",
+    "**Value Delivered:**\n",
+    "- Up to 70% reduction in manual data extraction time.\n",
+    "- Increased accuracy and standardization with structured fields."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a704e843-54be-4969-842b-713584cb3c35",
+   "metadata": {},
+   "source": [
+    "## Setup and Download Data\n",
+    "\n",
+    "Download the [LM317 Datasheet](https://www.ti.com/lit/ds/symlink/lm317.pdf) and setup LlamaExtract."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6e5b1f91-8785-44d4-a710-8be1b48b76de",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!mkdir -p data/lm317_structured_extraction\n",
+    "!wget https://www.ti.com/lit/ds/symlink/lm317.pdf -O data/lm317_structured_extraction/lm317.pdf"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f17b914a-00ed-4b63-8198-69fd7c4a7c62",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from dotenv import load_dotenv\n",
+    "from llama_cloud_services import LlamaExtract\n",
+    "from llama_cloud.core.api_error import ApiError\n",
+    "\n",
+    "# Load environment variables (ensure LLAMA_CLOUD_API_KEY is set in your .env file)\n",
+    "load_dotenv(override=True)\n",
+    "\n",
+    "# Initialize the LlamaExtract client\n",
+    "llama_extract = LlamaExtract(\n",
+    "    project_id=\"<project_id>\",\n",
+    "    organization_id=\"<organization_id>\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ed9f6e9a-96c8-4ee1-8b45-0b6a4f7dbbf1",
+   "metadata": {},
+   "source": [
+    "## Defining a Structured Extraction Schema\n",
+    "\n",
+    "We now define a rich Pydantic schema to extract technical specifications from the LM317 datasheet. In this schema:\n",
+    "\n",
+    "- The **output_voltage** and **input_voltage** fields are structured as ranges with separate minimum and maximum values and a unit.\n",
+    "- The **pin_configuration** field is structured to include a pin count and a descriptive layout.\n",
+    "- Additional technical fields (e.g., dropout voltage, max current) are captured as numbers.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4f7e9b44-5e69-4b30-9864-cd98f1e2a7d4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pydantic import BaseModel, Field\n",
+    "from typing import List\n",
+    "\n",
+    "\n",
+    "class VoltageRange(BaseModel):\n",
+    "    min_voltage: float = Field(..., description=\"Minimum voltage in volts\")\n",
+    "    max_voltage: float = Field(..., description=\"Maximum voltage in volts\")\n",
+    "    unit: str = Field(\"V\", description=\"Voltage unit\")\n",
+    "\n",
+    "\n",
+    "class PinConfiguration(BaseModel):\n",
+    "    pin_count: int = Field(..., description=\"Number of pins\")\n",
+    "    layout: str = Field(..., description=\"Detailed pin layout description\")\n",
+    "\n",
+    "\n",
+    "class LM317Spec(BaseModel):\n",
+    "    component_name: str = Field(..., description=\"Name of the component\")\n",
+    "    output_voltage: VoltageRange = Field(\n",
+    "        ..., description=\"Output voltage range specification\"\n",
+    "    )\n",
+    "    dropout_voltage: float = Field(..., description=\"Dropout voltage in volts\")\n",
+    "    max_current: float = Field(..., description=\"Maximum current rating in amperes\")\n",
+    "    input_voltage: VoltageRange = Field(\n",
+    "        ..., description=\"Input voltage range specification\"\n",
+    "    )\n",
+    "    pin_configuration: PinConfiguration = Field(\n",
+    "        ..., description=\"Pin configuration details\"\n",
+    "    )\n",
+    "    features: List[str] = Field([], description=\"List of additional technical features\")\n",
+    "\n",
+    "\n",
+    "class LM317Schema(BaseModel):\n",
+    "    specs: List[LM317Spec] = Field(\n",
+    "        ..., description=\"List of extracted LM317 technical specifications\"\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e0508e38-35be-446c-afe7-129e39553281",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "try:\n",
+    "    existing_agent = llama_extract.get_agent(name=\"lm317-datasheet\")\n",
+    "    if existing_agent:\n",
+    "        llama_extract.delete_agent(existing_agent.id)\n",
+    "except ApiError as e:\n",
+    "    if e.status_code == 404:\n",
+    "        pass\n",
+    "    else:\n",
+    "        raise"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bb197dfd-dd37-459e-8953-cc1b12f25bdd",
+   "metadata": {},
+   "source": [
+    "Here we use our balanced extraction mode."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e3defc0a-c685-4fbd-bbb1-1270f1442e72",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from llama_cloud import ExtractConfig\n",
+    "\n",
+    "extract_config = ExtractConfig(\n",
+    "    extraction_mode=\"BALANCED\",\n",
+    ")\n",
+    "\n",
+    "agent = llama_extract.create_agent(\n",
+    "    name=\"lm317-datasheet\", data_schema=LM317Schema, config=extract_config\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c0a0f9f9-2ef3-4a38-bd74-68d2c2e9e2d8",
+   "metadata": {},
+   "source": [
+    "## Extracting Information from the LM317 Datasheet\n",
+    "\n",
+    "For this demonstration, please download a publicly available LM317 voltage regulator datasheet (for example, from Texas Instruments) and save it as `lm317.pdf` in the `./data` directory. Then run the cell below to extract the structured technical specifications."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c58e8b7a-8f9b-46f3-8f72-3c2f96b49e8f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Uploading files: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:01<00:00,  1.08s/it]\n",
+      "Creating extraction jobs: 100%|████████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:00<00:00,  1.96it/s]\n",
+      "Extracting files: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [01:27<00:00, 87.38s/it]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Path to the LM317 datasheet PDF\n",
+    "lm317_pdf = \"./data/lm317_structured_extraction/lm317.pdf\"\n",
+    "\n",
+    "# Extract structured technical specifications from the datasheet\n",
+    "lm317_extract = agent.extract(lm317_pdf)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1a2e2e44-6c48-4a38-a6de-5f2f3c7d4d8b",
+   "metadata": {},
+   "source": [
+    "## Assessing the Extraction Results\n",
+    "\n",
+    "The output will be a consolidated list of LM317 technical specifications. For each entry, you should see structured fields including:\n",
+    "\n",
+    "- **component_name**\n",
+    "- **output_voltage** as a range (with separate `min_voltage` and `max_voltage` plus `unit`)\n",
+    "- **dropout_voltage** and **max_current** as numbers\n",
+    "- **input_voltage** as a structured range\n",
+    "- **pin_configuration** with a `pin_count` and `layout`\n",
+    "- **features** (if available)\n",
+    "\n",
+    "This structured approach makes it easier to standardize the information for downstream integration and verification. Engineers can click on the cited page numbers (in a UI that supports it) to validate the extraction."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fb2abc44-7c9b-4b19-958e-d0d7b390ae57",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'specs': [{'component_name': 'LM317',\n",
+       "   'output_voltage': {'min_voltage': 1.25, 'max_voltage': 37.0, 'unit': 'V'},\n",
+       "   'dropout_voltage': 0.0,\n",
+       "   'max_current': 1.5,\n",
+       "   'input_voltage': {'min_voltage': 4.25, 'max_voltage': 40.0, 'unit': 'V'},\n",
+       "   'pin_configuration': {'pin_count': 3,\n",
+       "    'layout': '1: ADJUST, 2: OUTPUT, 3: INPUT'},\n",
+       "   'features': ['Output voltage range adjustable from 1.25 V to 37 V',\n",
+       "    'Output current greater than 1.5 A',\n",
+       "    'Internal short-circuit current limiting',\n",
+       "    'Thermal overload protection',\n",
+       "    'Output safe-area compensation']}]}"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Display the extraction results\n",
+    "lm317_extract.data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c7a2a523-095e-40bf-b713-f509c13a7747",
+   "metadata": {},
+   "source": [
+    "You can also see the output result in the UI."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dc22dfa5-b667-4fb0-8dbe-24e401b12389",
+   "metadata": {},
+   "source": [
+    "![](data/lm317_structured_extraction/lm317_extraction.png)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e0e0c12a-9f89-4bb3-b40d-3e9f7c6d2fef",
+   "metadata": {},
+   "source": [
+    "## Conclusion\n",
+    "\n",
+    "This notebook demonstrated how to use LlamaExtract with a structured extraction schema for the LM317 voltage regulator datasheet. By defining detailed subfields (such as splitting voltage ranges into minimum and maximum values, and structuring the pin configuration), we ensure that the extracted data is standardized and traceable through page citations. This approach minimizes manual effort and improves accuracy, providing a robust example of an agentic document workflow for technical documentation processing.\n",
+    "\n",
+    "Feel free to modify or extend the schema to capture additional technical details or to suit your own use cases."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "llama_parse",
+   "language": "python",
+   "name": "llama_parse"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

examples/extract/resume_screening.ipynb

@@ -0,0 +1,834 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Extracting data from Resumes\n",
+    "\n",
+    "Let us assume that we are running a hiring process for a company and we have received a list of resumes from candidates. We want to extract structured data from the resumes so that we can run a screening process and shortlist candidates. \n",
+    "\n",
+    "Take a look at one of the resumes in the `data/resumes` directory. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "        <iframe\n",
+       "            width=\"600\"\n",
+       "            height=\"400\"\n",
+       "            src=\"./data/resumes/ai_researcher.pdf\"\n",
+       "            frameborder=\"0\"\n",
+       "            allowfullscreen\n",
+       "            \n",
+       "        ></iframe>\n",
+       "        "
+      ],
+      "text/plain": [
+       "<IPython.lib.display.IFrame at 0x109a7dcd0>"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import IFrame\n",
+    "\n",
+    "IFrame(src=\"./data/resumes/ai_researcher.pdf\", width=600, height=400)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You will notice that all the resumes have different layouts but contain common information like name, email, experience, education, etc. \n",
+    "\n",
+    "With LlamaExtract, we will show you how to:\n",
+    "- *Define* a data schema to extract the information of interest. \n",
+    "- *Iterate* over the data schema to generalize the schema for multiple resumes.\n",
+    "- *Finalize* the schema and schedule extractions for multiple resumes.\n",
+    "\n",
+    "We will start by defining a `LlamaExtract` client which provides a Python interface to the LlamaExtract API. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from dotenv import load_dotenv\n",
+    "from llama_cloud_services import LlamaExtract\n",
+    "\n",
+    "\n",
+    "# Load environment variables (put LLAMA_CLOUD_API_KEY in your .env file)\n",
+    "load_dotenv(override=True)\n",
+    "\n",
+    "# Optionally, add your project id/organization id\n",
+    "llama_extract = LlamaExtract()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Defining the data schema\n",
+    "\n",
+    "Next, let us try to extract two fields from the resume: `name` and `email`. We can either use a Python dictionary structure to define the `data_schema` as a JSON or use a Pydantic model instead, for brevity and convenience. In either case, our output is guaranteed to validate against this schema."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pydantic import BaseModel, Field\n",
+    "\n",
+    "\n",
+    "class Resume(BaseModel):\n",
+    "    name: str = Field(description=\"The name of the candidate\")\n",
+    "    email: str = Field(description=\"The email address of the candidate\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Uploading files: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:02<00:00,  2.20s/it]\n",
+      "Creating extraction jobs: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:02<00:00,  2.93s/it]\n",
+      "Extracting files: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:02<00:00,  2.94s/it]\n",
+      "Uploading files: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:00<00:00,  1.13it/s]\n",
+      "Creating extraction jobs: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:00<00:00,  1.80it/s]\n",
+      "Extracting files: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:15<00:00, 15.18s/it]\n",
+      "Uploading files: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:00<00:00,  1.16it/s]\n",
+      "Creating extraction jobs: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:00<00:00,  2.33it/s]\n",
+      "Extracting files: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:32<00:00, 32.86s/it]\n"
+     ]
+    }
+   ],
+   "source": [
+    "from llama_cloud.core.api_error import ApiError\n",
+    "\n",
+    "try:\n",
+    "    existing_agent = llama_extract.get_agent(name=\"resume-screening\")\n",
+    "    if existing_agent:\n",
+    "        llama_extract.delete_agent(existing_agent.id)\n",
+    "except ApiError as e:\n",
+    "    if e.status_code == 404:\n",
+    "        pass\n",
+    "    else:\n",
+    "        raise\n",
+    "\n",
+    "agent = llama_extract.create_agent(name=\"resume-screening\", data_schema=Resume)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[ExtractionAgent(id=1fef43b5-8230-43b4-9e80-c1cddf53889c, name=resume-screening),\n",
+       " ExtractionAgent(id=93f8508b-3570-46f0-ae62-6315b40043bd, name=receipt/noisebridge_receipt.pdf_56db3d92),\n",
+       " ExtractionAgent(id=08315f0e-7146-430b-99b8-9701cb3ace6a, name=receipt/noisebridge_receipt.pdf_5c4730a7),\n",
+       " ExtractionAgent(id=cfcd7756-015d-4dbd-b142-a3eefcb16cd3, name=resume/software_architect_resume.html_4a11cf15),\n",
+       " ExtractionAgent(id=17cb83d9-601e-4f5c-a7aa-286e3045bcb4, name=resume/software_architect_resume.html_0b7d84a8),\n",
+       " ExtractionAgent(id=adc8e88c-44d3-4613-a5aa-d666ef007494, name=slide/saas_slide.pdf_bcc627a5),\n",
+       " ExtractionAgent(id=189f14cd-6370-4476-a6ad-36eafbc62618, name=slide/saas_slide.pdf_065aa22b),\n",
+       " ExtractionAgent(id=b9938ca5-6225-43cb-89ea-b0065237792f, name=test2),\n",
+       " ExtractionAgent(id=574d37b8-59dc-41e9-bde0-5c506a8eb670, name=test)]"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "llama_extract.list_agents()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'name': 'Dr. Rachel Zhang', 'email': 'rachel.zhang@email.com'}"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "resume = agent.extract(\"./data/resumes/ai_researcher.pdf\")\n",
+    "resume.data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Iterating over the data schema\n",
+    "\n",
+    "Now that we have created a data schema, let us add more fields to the schema. We will add `experience` and `education` fields to the schema. \n",
+    "- We can create a new Pydantic model for each of these fields and represent `experience` and `education` as lists of these models. Doing this will allow us to extract multiple entities from the resume without having to pre-define how many experiences or education the candidate has. \n",
+    "- We have added a `description` parameter to provide more context for extraction. We can use `description` to provide example inputs/outputs for the extraction. \n",
+    "- Note that we have annotated the `start_date` and `end_date` fields with `Optional[str]` to indicate that these fields are optional. This is *important* because the schema will be used to extract data from multiple resumes and not all resumes will have the same format. A field must only be required if it is guaranteed to be present in all the resumes. \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from typing import List, Optional\n",
+    "\n",
+    "\n",
+    "class Education(BaseModel):\n",
+    "    institution: str = Field(description=\"The institution of the candidate\")\n",
+    "    degree: str = Field(description=\"The degree of the candidate\")\n",
+    "    start_date: Optional[str] = Field(\n",
+    "        default=None, description=\"The start date of the candidate's education\"\n",
+    "    )\n",
+    "    end_date: Optional[str] = Field(\n",
+    "        default=None, description=\"The end date of the candidate's education\"\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "class Experience(BaseModel):\n",
+    "    company: str = Field(description=\"The name of the company\")\n",
+    "    title: str = Field(description=\"The title of the candidate\")\n",
+    "    description: Optional[str] = Field(\n",
+    "        default=None, description=\"The description of the candidate's experience\"\n",
+    "    )\n",
+    "    start_date: Optional[str] = Field(\n",
+    "        default=None, description=\"The start date of the candidate's experience\"\n",
+    "    )\n",
+    "    end_date: Optional[str] = Field(\n",
+    "        default=None, description=\"The end date of the candidate's experience\"\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "class Resume(BaseModel):\n",
+    "    name: str = Field(description=\"The name of the candidate\")\n",
+    "    email: str = Field(description=\"The email address of the candidate\")\n",
+    "    links: List[str] = Field(\n",
+    "        description=\"The links to the candidate's social media profiles\"\n",
+    "    )\n",
+    "    experience: List[Experience] = Field(description=\"The candidate's experience\")\n",
+    "    education: List[Education] = Field(description=\"The candidate's education\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Next, we will update the `data_schema` for the `resume-screening` agent to use the new `Resume` model. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'name': 'Dr. Rachel Zhang',\n",
+       " 'email': 'rachel.zhang@email.com',\n",
+       " 'links': ['linkedin.com/in/rachelzhang',\n",
+       "  'github.com/rzhang-ai',\n",
+       "  'scholar.google.com/rachelzhang'],\n",
+       " 'experience': [{'company': 'DeepMind',\n",
+       "   'title': 'Senior Research Scientist',\n",
+       "   'description': '- Lead researcher on large-scale multi-task learning systems, developing novel architectures that improve cross-task generalization by 40%\\n- Pioneered new approach to zero-shot learning using contrastive training, published in NeurIPS 2023\\n- Built and led team of 6 researchers working on foundational ML models\\n- Developed novel regularization techniques for large language models, reducing catastrophic forgetting by 35%',\n",
+       "   'start_date': '2019',\n",
+       "   'end_date': 'Present'},\n",
+       "  {'company': 'Google Research',\n",
+       "   'title': 'Research Scientist',\n",
+       "   'description': '- Developed probabilistic frameworks for robust ML, published in ICML 2018\\n- Created novel attention mechanisms for computer vision models, improving accuracy by 25%\\n- Led collaboration with Google Brain team on efficient training methods for transformer models\\n- Mentored 4 PhD interns and collaborated with academic institutions',\n",
+       "   'start_date': '2015',\n",
+       "   'end_date': '2019'},\n",
+       "  {'company': 'Columbia University',\n",
+       "   'title': 'Research Assistant Professor',\n",
+       "   'description': '- Published seminal work on Bayesian optimization methods (cited 1000+ times)\\n- Taught graduate-level courses in Machine Learning and Statistical Learning Theory\\n- Supervised 5 PhD students and 3 MSc students\\n- Secured $500K in research grants for probabilistic ML research',\n",
+       "   'start_date': '2011',\n",
+       "   'end_date': '2015'}],\n",
+       " 'education': [{'institution': 'Columbia University',\n",
+       "   'degree': 'Ph.D. in Computer Science',\n",
+       "   'start_date': '2007',\n",
+       "   'end_date': '2011'},\n",
+       "  {'institution': 'Stanford University',\n",
+       "   'degree': 'M.S. in Computer Science',\n",
+       "   'start_date': '2005',\n",
+       "   'end_date': '2007'}]}"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent.data_schema = Resume\n",
+    "resume = agent.extract(\"./data/resumes/ai_researcher.pdf\")\n",
+    "resume.data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This is a good start. Let us add a few more fields to the schema and re-run the extraction. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class TechnicalSkills(BaseModel):\n",
+    "    programming_languages: List[str] = Field(\n",
+    "        description=\"The programming languages the candidate is proficient in.\"\n",
+    "    )\n",
+    "    frameworks: List[str] = Field(\n",
+    "        description=\"The tools/frameworks the candidate is proficient in, e.g. React, Django, PyTorch, etc.\"\n",
+    "    )\n",
+    "    skills: List[str] = Field(\n",
+    "        description=\"Other general skills the candidate is proficient in, e.g. Data Engineering, Machine Learning, etc.\"\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "class Resume(BaseModel):\n",
+    "    name: str = Field(description=\"The name of the candidate\")\n",
+    "    email: str = Field(description=\"The email address of the candidate\")\n",
+    "    links: List[str] = Field(\n",
+    "        description=\"The links to the candidate's social media profiles\"\n",
+    "    )\n",
+    "    experience: List[Experience] = Field(description=\"The candidate's experience\")\n",
+    "    education: List[Education] = Field(description=\"The candidate's education\")\n",
+    "    technical_skills: TechnicalSkills = Field(\n",
+    "        description=\"The candidate's technical skills\"\n",
+    "    )\n",
+    "    key_accomplishments: str = Field(\n",
+    "        description=\"Summarize the candidates highest achievements.\"\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'name': 'Dr. Rachel Zhang, Ph.D.',\n",
+       " 'email': 'rachel.zhang@email.com',\n",
+       " 'links': ['linkedin.com/in/rachelzhang',\n",
+       "  'github.com/rzhang-ai',\n",
+       "  'scholar.google.com/rachelzhang'],\n",
+       " 'experience': [{'company': 'DeepMind',\n",
+       "   'title': 'Senior Research Scientist',\n",
+       "   'description': 'Lead researcher on large-scale multi-task learning systems, developing novel architectures that improve cross-task generalization by 40%\\nPioneered new approach to zero-shot learning using contrastive training, published in NeurIPS 2023\\nBuilt and led team of 6 researchers working on foundational ML models\\nDeveloped novel regularization techniques for large language models, reducing catastrophic forgetting by 35%',\n",
+       "   'start_date': '2019',\n",
+       "   'end_date': 'Present'},\n",
+       "  {'company': 'Google Research',\n",
+       "   'title': 'Research Scientist',\n",
+       "   'description': 'Developed probabilistic frameworks for robust ML, published in ICML 2018\\nCreated novel attention mechanisms for computer vision models, improving accuracy by 25%\\nLed collaboration with Google Brain team on efficient training methods for transformer models\\nMentored 4 PhD interns and collaborated with academic institutions',\n",
+       "   'start_date': '2015',\n",
+       "   'end_date': '2019'},\n",
+       "  {'company': 'Columbia University',\n",
+       "   'title': 'Research Assistant Professor',\n",
+       "   'description': 'Published seminal work on Bayesian optimization methods (cited 1000+ times)\\nTaught graduate-level courses in Machine Learning and Statistical Learning Theory\\nSupervised 5 PhD students and 3 MSc students\\nSecured $500K in research grants for probabilistic ML research',\n",
+       "   'start_date': '2011',\n",
+       "   'end_date': '2015'}],\n",
+       " 'education': [{'institution': 'Columbia University',\n",
+       "   'degree': 'Ph.D. in Computer Science',\n",
+       "   'start_date': '2007',\n",
+       "   'end_date': '2011'},\n",
+       "  {'institution': 'Stanford University',\n",
+       "   'degree': 'M.S. in Computer Science',\n",
+       "   'start_date': '2005',\n",
+       "   'end_date': '2007'}],\n",
+       " 'technical_skills': {'programming_languages': ['Python',\n",
+       "   'C++',\n",
+       "   'Julia',\n",
+       "   'CUDA'],\n",
+       "  'frameworks': ['PyTorch', 'TensorFlow', 'JAX', 'Ray'],\n",
+       "  'skills': ['Deep Learning',\n",
+       "   'Reinforcement Learning',\n",
+       "   'Probabilistic Models',\n",
+       "   'Multi-Task Learning',\n",
+       "   'Zero-Shot Learning',\n",
+       "   'Neural Architecture Search']},\n",
+       " 'key_accomplishments': 'AI researcher with 12+ years of experience spanning classical machine learning, deep learning, and probabilistic modeling. Led groundbreaking research in reinforcement learning, generative models, and multi-task learning. Published 25+ papers in top-tier conferences (NeurIPS, ICML, ICLR). Strong track record of transitioning theoretical advances into practical applications in both academic and industrial settings.'}"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent.data_schema = Resume\n",
+    "resume = agent.extract(\"./data/resumes/ai_researcher.pdf\")\n",
+    "resume.data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Finalizing the schema\n",
+    "\n",
+    "This is great! We have extracted a lot of key information from the resume that is well-typed and can be used downstream for further processing. Until now, this data is ephemeral and will be lost if we close the session. Let us save the state of our extraction and use it to extract data from multiple resumes. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "agent.save()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'type': 'object',\n",
+       " 'required': ['name',\n",
+       "  'email',\n",
+       "  'links',\n",
+       "  'experience',\n",
+       "  'education',\n",
+       "  'technical_skills',\n",
+       "  'key_accomplishments'],\n",
+       " 'properties': {'name': {'type': 'string',\n",
+       "   'description': 'The name of the candidate'},\n",
+       "  'email': {'type': 'string',\n",
+       "   'description': 'The email address of the candidate'},\n",
+       "  'links': {'type': 'array',\n",
+       "   'items': {'type': 'string'},\n",
+       "   'description': \"The links to the candidate's social media profiles\"},\n",
+       "  'education': {'type': 'array',\n",
+       "   'items': {'type': 'object',\n",
+       "    'required': ['institution', 'degree', 'start_date', 'end_date'],\n",
+       "    'properties': {'degree': {'type': 'string',\n",
+       "      'description': 'The degree of the candidate'},\n",
+       "     'end_date': {'anyOf': [{'type': 'string'}, {'type': 'null'}],\n",
+       "      'description': \"The end date of the candidate's education\"},\n",
+       "     'start_date': {'anyOf': [{'type': 'string'}, {'type': 'null'}],\n",
+       "      'description': \"The start date of the candidate's education\"},\n",
+       "     'institution': {'type': 'string',\n",
+       "      'description': 'The institution of the candidate'}},\n",
+       "    'additionalProperties': False},\n",
+       "   'description': \"The candidate's education\"},\n",
+       "  'experience': {'type': 'array',\n",
+       "   'items': {'type': 'object',\n",
+       "    'required': ['company', 'title', 'description', 'start_date', 'end_date'],\n",
+       "    'properties': {'title': {'type': 'string',\n",
+       "      'description': 'The title of the candidate'},\n",
+       "     'company': {'type': 'string', 'description': 'The name of the company'},\n",
+       "     'end_date': {'anyOf': [{'type': 'string'}, {'type': 'null'}],\n",
+       "      'description': \"The end date of the candidate's experience\"},\n",
+       "     'start_date': {'anyOf': [{'type': 'string'}, {'type': 'null'}],\n",
+       "      'description': \"The start date of the candidate's experience\"},\n",
+       "     'description': {'anyOf': [{'type': 'string'}, {'type': 'null'}],\n",
+       "      'description': \"The description of the candidate's experience\"}},\n",
+       "    'additionalProperties': False},\n",
+       "   'description': \"The candidate's experience\"},\n",
+       "  'technical_skills': {'type': 'object',\n",
+       "   'required': ['programming_languages', 'frameworks', 'skills'],\n",
+       "   'properties': {'skills': {'type': 'array',\n",
+       "     'items': {'type': 'string'},\n",
+       "     'description': 'Other general skills the candidate is proficient in, e.g. Data Engineering, Machine Learning, etc.'},\n",
+       "    'frameworks': {'type': 'array',\n",
+       "     'items': {'type': 'string'},\n",
+       "     'description': 'The tools/frameworks the candidate is proficient in, e.g. React, Django, PyTorch, etc.'},\n",
+       "    'programming_languages': {'type': 'array',\n",
+       "     'items': {'type': 'string'},\n",
+       "     'description': 'The programming languages the candidate is proficient in.'}},\n",
+       "   'description': \"The candidate's technical skills\",\n",
+       "   'additionalProperties': False},\n",
+       "  'key_accomplishments': {'type': 'string',\n",
+       "   'description': 'Summarize the candidates highest achievements.'}},\n",
+       " 'additionalProperties': False}"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent = llama_extract.get_agent(\"resume-screening\")\n",
+    "agent.data_schema  # Latest schema should be returned"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Queueing extractions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "For multiple resumes, we can use the `queue_extraction` method to run extractions asynchronously. This is ideal for processing batch extraction jobs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Uploading files: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 3/3 [00:01<00:00,  2.13it/s]\n",
+      "Creating extraction jobs: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 3/3 [00:00<00:00,  5.83it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "\n",
+    "# All resumes in the data/resumes directory\n",
+    "resumes = []\n",
+    "\n",
+    "with os.scandir(\"./data/resumes\") as entries:\n",
+    "    for entry in entries:\n",
+    "        if entry.is_file():\n",
+    "            resumes.append(entry.path)\n",
+    "\n",
+    "jobs = await agent.queue_extraction(resumes)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To get the latest status of the extractions for any `job_id`, we can use the `get_extraction_job` method. \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<StatusEnum.PENDING: 'PENDING'>,\n",
+       " <StatusEnum.PENDING: 'PENDING'>,\n",
+       " <StatusEnum.PENDING: 'PENDING'>]"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "[agent.get_extraction_job(job_id=job.id).status for job in jobs]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We notice that all extraction runs are in a PENDING state. We can check back again to see if the extractions have completed. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<StatusEnum.SUCCESS: 'SUCCESS'>,\n",
+       " <StatusEnum.SUCCESS: 'SUCCESS'>,\n",
+       " <StatusEnum.SUCCESS: 'SUCCESS'>]"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "[agent.get_extraction_job(job_id=job.id).status for job in jobs]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Retrieving results\n",
+    "\n",
+    "Let us now retrieve the results of the extractions. If the status of the extraction is `SUCCESS`, we can retrieve the data from the `data` field. In case there are errors (status = `ERROR`), we can retrieve the error message from the `error` field. \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "results = []\n",
+    "for job in jobs:\n",
+    "    extract_run = agent.get_extraction_run_for_job(job.id)\n",
+    "    if extract_run.status == \"SUCCESS\":\n",
+    "        results.append(extract_run.data)\n",
+    "    else:\n",
+    "        print(f\"Extraction status for job {job.id}: {extract_run.status}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'name': 'Dr. Rachel Zhang, Ph.D.',\n",
+       " 'email': 'rachel.zhang@email.com',\n",
+       " 'links': ['linkedin.com/in/rachelzhang',\n",
+       "  'github.com/rzhang-ai',\n",
+       "  'scholar.google.com/rachelzhang'],\n",
+       " 'education': [{'degree': 'Ph.D. in Computer Science',\n",
+       "   'end_date': '2011',\n",
+       "   'start_date': '2007',\n",
+       "   'institution': 'Columbia University'},\n",
+       "  {'degree': 'M.S. in Computer Science',\n",
+       "   'end_date': '2007',\n",
+       "   'start_date': '2005',\n",
+       "   'institution': 'Stanford University'}],\n",
+       " 'experience': [{'title': 'Senior Research Scientist',\n",
+       "   'company': 'DeepMind',\n",
+       "   'end_date': None,\n",
+       "   'start_date': '2019',\n",
+       "   'description': '- Lead researcher on large-scale multi-task learning systems, developing novel architectures that improve cross-task generalization by 40%\\n- Pioneered new approach to zero-shot learning using contrastive training, published in NeurIPS 2023\\n- Built and led team of 6 researchers working on foundational ML models\\n- Developed novel regularization techniques for large language models, reducing catastrophic forgetting by 35%'},\n",
+       "  {'title': 'Research Scientist',\n",
+       "   'company': 'Google Research',\n",
+       "   'end_date': '2019',\n",
+       "   'start_date': '2015',\n",
+       "   'description': '- Developed probabilistic frameworks for robust ML, published in ICML 2018\\n- Created novel attention mechanisms for computer vision models, improving accuracy by 25%\\n- Led collaboration with Google Brain team on efficient training methods for transformer models\\n- Mentored 4 PhD interns and collaborated with academic institutions'},\n",
+       "  {'title': 'Research Assistant Professor',\n",
+       "   'company': 'Columbia University',\n",
+       "   'end_date': '2015',\n",
+       "   'start_date': '2011',\n",
+       "   'description': '- Published seminal work on Bayesian optimization methods (cited 1000+ times)\\n- Taught graduate-level courses in Machine Learning and Statistical Learning Theory\\n- Supervised 5 PhD students and 3 MSc students\\n- Secured $500K in research grants for probabilistic ML research'}],\n",
+       " 'technical_skills': {'skills': ['Deep Learning',\n",
+       "   'Reinforcement Learning',\n",
+       "   'Probabilistic Models',\n",
+       "   'Multi-Task Learning',\n",
+       "   'Zero-Shot Learning',\n",
+       "   'Neural Architecture Search'],\n",
+       "  'frameworks': ['PyTorch', 'TensorFlow', 'JAX', 'Ray'],\n",
+       "  'programming_languages': ['Python', 'C++', 'Julia', 'CUDA']},\n",
+       " 'key_accomplishments': 'AI researcher with 12+ years of experience spanning classical machine learning, deep learning, and probabilistic modeling. Led groundbreaking research in reinforcement learning, generative models, and multi-task learning. Published 25+ papers in top-tier conferences (NeurIPS, ICML, ICLR). Strong track record of transitioning theoretical advances into practical applications in both academic and industrial settings.'}"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'name': 'Alex Park',\n",
+       " 'email': 'alex park@email.com',\n",
+       " 'links': ['linkedin.com/in/alexpark'],\n",
+       " 'education': [{'degree': 'M.S. Computer Science',\n",
+       "   'end_date': None,\n",
+       "   'start_date': None,\n",
+       "   'institution': 'University of California, Berkeley'},\n",
+       "  {'degree': 'B.S. Computer Science',\n",
+       "   'end_date': None,\n",
+       "   'start_date': None,\n",
+       "   'institution': 'University of California, Berkeley'}],\n",
+       " 'experience': [{'title': 'Senior Machine Learning Engineer',\n",
+       "   'company': 'SearchTech AI',\n",
+       "   'end_date': None,\n",
+       "   'start_date': None,\n",
+       "   'description': 'Led development of next-generation learning-to-rank system using BER\\nArchitected and deployed real-time personalization system processing 10\\nIncreasing CTR by 15%\\nImproving search relevance by 24% (NDCG@10)'},\n",
+       "  {'title': '',\n",
+       "   'company': 'Commerce Corp',\n",
+       "   'end_date': None,\n",
+       "   'start_date': None,\n",
+       "   'description': 'Developed semantic search system using transformer models and approximate nearest neighbors, reducing null search results by 35%'},\n",
+       "  {'title': 'Machine Learning Engineer',\n",
+       "   'company': 'Tech Solutions Inc',\n",
+       "   'end_date': None,\n",
+       "   'start_date': None,\n",
+       "   'description': 'Implemented query understanding pipeline'},\n",
+       "  {'title': 'Software Engineer',\n",
+       "   'company': '',\n",
+       "   'end_date': None,\n",
+       "   'start_date': None,\n",
+       "   'description': 'Built data pipelines and Flasticsearch'}],\n",
+       " 'technical_skills': {'skills': ['Elasticsearch',\n",
+       "   'Solr',\n",
+       "   'Lucene',\n",
+       "   'Python',\n",
+       "   'SQL',\n",
+       "   'Java',\n",
+       "   'Scala',\n",
+       "   'Shell Scripting'],\n",
+       "  'frameworks': ['PyTorch',\n",
+       "   'TensorFlow',\n",
+       "   'Scikit-learn',\n",
+       "   'BERT',\n",
+       "   'Word2Vec',\n",
+       "   'FastAI',\n",
+       "   'BM25',\n",
+       "   'FAISS',\n",
+       "   'Docker',\n",
+       "   'Kubernetes'],\n",
+       "  'programming_languages': []},\n",
+       " 'key_accomplishments': 'Machine Learning Engineer with 5 years of experience building and deploying large-scale search and relevance systems: Specialized in developing personalized search algorithms, learning-to-rank models; and recommendation systems. Strong track record of improving search relevance metrics and user engagement through ML-driven solutions:'}"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results[1]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'name': 'Sarah Chen',\n",
+       " 'email': 'sarah.chen@email.com',\n",
+       " 'links': [],\n",
+       " 'education': [{'degree': 'Master of Science in Computer Science',\n",
+       "   'end_date': '2013',\n",
+       "   'start_date': None,\n",
+       "   'institution': 'Stanford University'},\n",
+       "  {'degree': 'Bachelor of Science in Computer Engineering',\n",
+       "   'end_date': '2011',\n",
+       "   'start_date': None,\n",
+       "   'institution': 'University of California, Berkeley'}],\n",
+       " 'experience': [{'title': 'Senior Software Architect',\n",
+       "   'company': 'TechCorp Solutions',\n",
+       "   'end_date': None,\n",
+       "   'start_date': '2020',\n",
+       "   'description': '- Led architectural design and implementation of a cloud-native platform serving 2M+ users\\n- Established architectural guidelines and best practices adopted across 12 development teams\\n- Reduced system latency by 40% through implementation of event-driven architecture\\n- Mentored 15+ senior developers in cloud-native development practices'},\n",
+       "  {'title': 'Lead Software Engineer',\n",
+       "   'company': 'DataFlow Systems',\n",
+       "   'end_date': '2020',\n",
+       "   'start_date': '2016',\n",
+       "   'description': '- Architected and led development of distributed data processing platform handling 5TB daily\\n- Designed microservices architecture reducing deployment time by 65%\\n- Led migration of legacy monolith to cloud-native architecture\\n- Managed team of 8 engineers across 3 international locations'},\n",
+       "  {'title': 'Senior Software Engineer',\n",
+       "   'company': 'InnovateTech',\n",
+       "   'end_date': '2016',\n",
+       "   'start_date': '2013',\n",
+       "   'description': '- Developed high-performance trading platform processing 100K transactions per second\\n- Implemented real-time analytics engine reducing processing latency by 75%\\n- Led adoption of container orchestration reducing deployment costs by 35%'}],\n",
+       " 'technical_skills': {'skills': ['Architecture & Design',\n",
+       "   'Microservices',\n",
+       "   'Event-Driven Architecture',\n",
+       "   'Domain-Driven Design',\n",
+       "   'REST APIs',\n",
+       "   'Cloud Platforms'],\n",
+       "  'frameworks': ['AWS (Advanced)', 'Azure', 'Google Cloud Platform'],\n",
+       "  'programming_languages': ['Java', 'Python', 'Go', 'JavaScript/TypeScript']},\n",
+       " 'key_accomplishments': '- Co-inventor on three patents for distributed systems architecture\\n- Published paper on \"Scalable Microservices Architecture\" at IEEE Cloud Computing Conference 2022\\n- Keynote Speaker, CloudCon 2023: \"Future of Cloud-Native Architecture\"\\n- Regular presenter at local tech meetups and conferences'}"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results[2]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Congratulations! You now have an agent that can extract structured data from resumes. \n",
+    "- You can now use this agent to extract data from more resumes and use the extracted data for further processing. \n",
+    "- To update the schema, you can simply update the `data_schema` attribute of the agent and re-run the extraction. \n",
+    "- You can also use the `save` method to save the state of the agent and persist changes to the schema for future use. \n",
+    "\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

examples/extract/solar_panel_e2e_comparison.ipynb

@@ -0,0 +1,452 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "00f6713b-2a32-4f8f-80e5-9a7d9b6e3b90",
+   "metadata": {},
+   "source": [
+    "# Solar Panel Datasheet Comparison Workflow\n",
+    "\n",
+    "<a href=\"https://colab.research.google.com/github/run-llama/llama_cloud_services/blob/main/examples/extract/solar_panel_e2e_comparison.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
+    "\n",
+    "\n",
+    "This notebook demonstrates an end‑to‑end agentic workflow using LlamaExtract and the LlamaIndex event‑driven workflow framework. In this workflow, we:\n",
+    "\n",
+    "1. **Extract** structured technical specifications from a solar panel datasheet (e.g. a PDF downloaded from a vendor).\n",
+    "2. **Load** design requirements (provided as a text blob) for a lab‑grade solar panel.\n",
+    "3. **Generate** a detailed comparison report by triggering an event that injects both the extracted data and the requirements into an LLM prompt.\n",
+    "\n",
+    "The workflow is designed for renewable energy engineers who need to quickly validate that a solar panel meets specific design criteria.\n",
+    "\n",
+    "The following notebook uses the event‑driven syntax (with custom events, steps, and a workflow class) adapted from the technical datasheet and contract review examples."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "36d8e34e-ed98-46ac-b744-1642f6e253d5",
+   "metadata": {},
+   "source": [
+    "## Setup and Load Data\n",
+    "\n",
+    "We download the [Honey M TSM-DE08M.08(II) datasheet](https://static.trinasolar.com/sites/default/files/EU_Datasheet_HoneyM_DE08M.08%28II%29_2021_A.pdf) as a PDF.\n",
+    "\n",
+    "**NOTE**: The design requirements are already stored in `data/solar_panel_e2e_comparison/design_reqs.txt`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1de7b1b3-c285-492c-8b2e-b37974b4fc63",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "--2025-04-01 14:47:56--  https://static.trinasolar.com/sites/default/files/EU_Datasheet_HoneyM_DE08M.08%28II%29_2021_A.pdf\n",
+      "Resolving static.trinasolar.com (static.trinasolar.com)... 47.246.23.232, 47.246.23.234, 47.246.23.227, ...\n",
+      "Connecting to static.trinasolar.com (static.trinasolar.com)|47.246.23.232|:443... connected.\n",
+      "WARNING: cannot verify static.trinasolar.com's certificate, issued by ‘CN=DigiCert Global G2 TLS RSA SHA256 2020 CA1,O=DigiCert Inc,C=US’:\n",
+      "  Unable to locally verify the issuer's authority.\n",
+      "HTTP request sent, awaiting response... 200 OK\n",
+      "Length: 1888183 (1.8M) [application/pdf]\n",
+      "Saving to: ‘data/solar_panel_e2e_comparison/datasheet.pdf’\n",
+      "\n",
+      "data/solar_panel_e2 100%[===================>]   1.80M  7.47MB/s    in 0.2s    \n",
+      "\n",
+      "2025-04-01 14:47:56 (7.47 MB/s) - ‘data/solar_panel_e2e_comparison/datasheet.pdf’ saved [1888183/1888183]\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "!wget https://static.trinasolar.com/sites/default/files/EU_Datasheet_HoneyM_DE08M.08%28II%29_2021_A.pdf -O data/solar_panel_e2e_comparison/datasheet.pdf --no-check-certificate"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "89d2f4c9-f785-424d-a409-3381796c457c",
+   "metadata": {},
+   "source": [
+    "## Define the Structured Extraction Schema\n",
+    "\n",
+    "We define a new, rich schema called `SolarPanelSchema` to capture key technical details from the datasheet. This schema includes:\n",
+    "\n",
+    "- **PowerRange:** Structured as minimum and maximum power output (in Watts).\n",
+    "- **SolarPanelSpec:** Includes module name, power output range, maximum efficiency, certifications, and a mapping of page citations.\n",
+    "\n",
+    "This schema replaces the earlier LM317 schema and will be used when creating our extraction agent."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bfb40d48-36e0-4b1c-97a1-32a1704c582b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pydantic import BaseModel, Field\n",
+    "from typing import List\n",
+    "\n",
+    "\n",
+    "class PowerRange(BaseModel):\n",
+    "    min_power: float = Field(..., description=\"Minimum power output in Watts\")\n",
+    "    max_power: float = Field(..., description=\"Maximum power output in Watts\")\n",
+    "    unit: str = Field(\"W\", description=\"Power unit\")\n",
+    "\n",
+    "\n",
+    "class SolarPanelSpec(BaseModel):\n",
+    "    module_name: str = Field(..., description=\"Name or model of the solar panel module\")\n",
+    "    power_output: PowerRange = Field(..., description=\"Power output range\")\n",
+    "    maximum_efficiency: float = Field(\n",
+    "        ..., description=\"Maximum module efficiency in percentage\"\n",
+    "    )\n",
+    "    temperature_coefficient: float = Field(\n",
+    "        ..., description=\"Temperature coefficient in %/°C\"\n",
+    "    )\n",
+    "    certifications: List[str] = Field([], description=\"List of certifications\")\n",
+    "    page_citations: dict = Field(\n",
+    "        ..., description=\"Mapping of each extracted field to its page numbers\"\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "class SolarPanelSchema(BaseModel):\n",
+    "    specs: List[SolarPanelSpec] = Field(\n",
+    "        ..., description=\"List of extracted solar panel specifications\"\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "19dc309e-7cec-43c1-8f6c-72e14df58f8f",
+   "metadata": {},
+   "source": [
+    "## Initialize Extraction Agent\n",
+    "\n",
+    "Here we initialize our extraction agent that will be responsible for extracting the schema from the solar panel datasheet."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c9d9f4a2-2e14-493d-8a7e-d01159d38b8f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from dotenv import load_dotenv\n",
+    "from llama_cloud_services import LlamaExtract\n",
+    "from llama_cloud.core.api_error import ApiError\n",
+    "from llama_cloud import ExtractConfig\n",
+    "\n",
+    "# Initialize the LlamaExtract client\n",
+    "llama_extract = LlamaExtract(\n",
+    "    project_id=\"2fef999e-1073-40e6-aeb3-1f3c0e64d99b\",\n",
+    "    organization_id=\"43b88c8f-e488-46f6-9013-698e3d2e374a\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ec0eb2a7-6e02-45da-a6af-227e2f7c81f2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "try:\n",
+    "    existing_agent = llama_extract.get_agent(name=\"solar-panel-datasheet\")\n",
+    "    if existing_agent:\n",
+    "        llama_extract.delete_agent(existing_agent.id)\n",
+    "except ApiError as e:\n",
+    "    if e.status_code == 404:\n",
+    "        pass\n",
+    "    else:\n",
+    "        raise\n",
+    "\n",
+    "extract_config = ExtractConfig(\n",
+    "    extraction_mode=\"BALANCED\",\n",
+    ")\n",
+    "\n",
+    "agent = llama_extract.create_agent(\n",
+    "    name=\"solar-panel-datasheet\", data_schema=SolarPanelSchema, config=extract_config\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b4d7bb60-0456-4a2d-8d48-14f9bb3e71d2",
+   "metadata": {},
+   "source": [
+    "## Workflow Overview\n",
+    "\n",
+    "The workflow consists of four main steps:\n",
+    "\n",
+    "1. **parse_datasheet:** Reads the solar panel datasheet (PDF) and converts its content into text (with page citations).\n",
+    "2. **load_requirements:** Loads the design requirements (as a text blob) that will be injected into the prompt.\n",
+    "3. **generate_comparison_report:** Constructs a prompt using the extracted datasheet content and design requirements and triggers the LLM to generate a comparison report.\n",
+    "4. **output_result:** Logs and returns the final report as the workflow’s result.\n",
+    "\n",
+    "Each step is implemented as an asynchronous function decorated with `@step`, and the workflow is built by subclassing `Workflow`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7c482e3a-66b4-4e1b-8d2d-9a9c6b3967f3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from llama_index.core.workflow import (\n",
+    "    Event,\n",
+    "    StartEvent,\n",
+    "    StopEvent,\n",
+    "    Context,\n",
+    "    Workflow,\n",
+    "    step,\n",
+    ")\n",
+    "from llama_index.llms.openai import OpenAI\n",
+    "from llama_index.core.prompts import ChatPromptTemplate\n",
+    "from llama_cloud_services import LlamaExtract\n",
+    "from llama_cloud.core.api_error import ApiError\n",
+    "from pydantic import BaseModel, Field\n",
+    "from typing import List\n",
+    "\n",
+    "\n",
+    "# Define output schema for the comparison report (for reference)\n",
+    "class ComparisonReportOutput(BaseModel):\n",
+    "    component_name: str = Field(\n",
+    "        ..., description=\"The name of the component being evaluated.\"\n",
+    "    )\n",
+    "    meets_requirements: bool = Field(\n",
+    "        ...,\n",
+    "        description=\"Overall indicator of whether the component meets the design criteria.\",\n",
+    "    )\n",
+    "    summary: str = Field(..., description=\"A brief summary of the evaluation results.\")\n",
+    "    details: dict = Field(\n",
+    "        ..., description=\"Detailed comparisons for each key parameter.\"\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "# Define custom events\n",
+    "\n",
+    "\n",
+    "class DatasheetParseEvent(Event):\n",
+    "    datasheet_content: dict\n",
+    "\n",
+    "\n",
+    "class RequirementsLoadEvent(Event):\n",
+    "    requirements_text: str\n",
+    "\n",
+    "\n",
+    "class ComparisonReportEvent(Event):\n",
+    "    report: ComparisonReportOutput\n",
+    "\n",
+    "\n",
+    "class LogEvent(Event):\n",
+    "    msg: str\n",
+    "    delta: bool = False\n",
+    "\n",
+    "\n",
+    "# For our demonstration, we assume that LlamaExtract is used to parse the datasheet into text.\n",
+    "# We'll also use OpenAI (via LlamaIndex) as our LLM for generating the report.\n",
+    "\n",
+    "llm = OpenAI(model=\"gpt-4o\")  # or your preferred model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "67a0c391-c7f5-4b93-8d6b-9e31b2d7a817",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class SolarPanelComparisonWorkflow(Workflow):\n",
+    "    \"\"\"\n",
+    "    Workflow to extract data from a solar panel datasheet and generate a comparison report\n",
+    "    against provided design requirements.\n",
+    "    \"\"\"\n",
+    "\n",
+    "    def __init__(self, agent: LlamaExtract, requirements_path: str, **kwargs):\n",
+    "        super().__init__(**kwargs)\n",
+    "        self.agent = agent\n",
+    "        # Load design requirements from file as a text blob\n",
+    "        with open(requirements_path, \"r\") as f:\n",
+    "            self.requirements_text = f.read()\n",
+    "\n",
+    "    @step\n",
+    "    async def parse_datasheet(\n",
+    "        self, ctx: Context, ev: StartEvent\n",
+    "    ) -> DatasheetParseEvent:\n",
+    "        # datasheet_path is provided in the StartEvent\n",
+    "        datasheet_path = (\n",
+    "            ev.datasheet_path\n",
+    "        )  # e.g., \"./data/solar_panel_comparison/datasheet.pdf\"\n",
+    "        extraction_result = await self.agent.aextract(datasheet_path)\n",
+    "        datasheet_dict = (\n",
+    "            extraction_result.data\n",
+    "        )  # assumed to be a string with page citations\n",
+    "        await ctx.set(\"datasheet_content\", datasheet_dict)\n",
+    "        ctx.write_event_to_stream(LogEvent(msg=\"Datasheet parsed successfully.\"))\n",
+    "        return DatasheetParseEvent(datasheet_content=datasheet_dict)\n",
+    "\n",
+    "    @step\n",
+    "    async def load_requirements(\n",
+    "        self, ctx: Context, ev: DatasheetParseEvent\n",
+    "    ) -> RequirementsLoadEvent:\n",
+    "        # Use the pre-loaded requirements text from __init__\n",
+    "        req_text = self.requirements_text\n",
+    "        ctx.write_event_to_stream(LogEvent(msg=\"Design requirements loaded.\"))\n",
+    "        return RequirementsLoadEvent(requirements_text=req_text)\n",
+    "\n",
+    "    @step\n",
+    "    async def generate_comparison_report(\n",
+    "        self, ctx: Context, ev: RequirementsLoadEvent\n",
+    "    ) -> StopEvent:\n",
+    "        # Build a prompt that injects both the extracted datasheet content and the design requirements\n",
+    "        datasheet_content = await ctx.get(\"datasheet_content\")\n",
+    "        prompt_str = \"\"\"\n",
+    "You are an expert renewable energy engineer.\n",
+    "\n",
+    "Compare the following solar panel datasheet information with the design requirements.\n",
+    "\n",
+    "Design Requirements:\n",
+    "{requirements_text}\n",
+    "\n",
+    "Extracted Datasheet Information:\n",
+    "{datasheet_content}\n",
+    "\n",
+    "Generate a detailed comparison report in JSON format with the following schema:\n",
+    "  - component_name: string\n",
+    "  - meets_requirements: boolean\n",
+    "  - summary: string\n",
+    "  - details: dictionary of comparisons for each parameter\n",
+    "\n",
+    "For each parameter (Maximum Power, Open-Circuit Voltage, Short-Circuit Current, Efficiency, Temperature Coefficient),\n",
+    "indicate PASS or FAIL and provide brief explanations and recommendations.\n",
+    "\"\"\"\n",
+    "\n",
+    "        # extract from contract\n",
+    "        prompt = ChatPromptTemplate.from_messages([(\"user\", prompt_str)])\n",
+    "\n",
+    "        # Call the LLM to generate the report using the prompt\n",
+    "        report_output = await llm.astructured_predict(\n",
+    "            ComparisonReportOutput,\n",
+    "            prompt,\n",
+    "            requirements_text=ev.requirements_text,\n",
+    "            datasheet_content=str(datasheet_content),\n",
+    "        )\n",
+    "        ctx.write_event_to_stream(LogEvent(msg=\"Comparison report generated.\"))\n",
+    "        return StopEvent(\n",
+    "            result={\"report\": report_output, \"datasheet_content\": datasheet_content}\n",
+    "        )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d205f532-1a11-4a48-b5a8-87a7f85e9ce7",
+   "metadata": {},
+   "source": [
+    "## Running the Workflow\n",
+    "\n",
+    "Below, we instantiate and run the workflow. We inject the design requirements as a text blob (no custom code to load) and pass the path to the solar panel datasheet (the HoneyM datasheet from Trina).\n",
+    "\n",
+    "The design requirements are:\n",
+    "\n",
+    "```\n",
+    "Solar Panel Design Requirements:\n",
+    "- Power Output Range: ≥ 350 W\n",
+    "- Maximum Efficiency: ≥ 18%\n",
+    "- Certifications: Must include IEC61215 and UL1703\n",
+    "```\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6b24fa61-a2f5-4ebb-84eb-1c9b48683b1b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import nest_asyncio\n",
+    "\n",
+    "nest_asyncio.apply()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a68bdffd-ac3c-4dcc-ba35-65939c2a6bfe",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running step parse_datasheet\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Uploading files: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:01<00:00,  1.17s/it]\n",
+      "Creating extraction jobs: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:00<00:00,  3.07it/s]\n",
+      "Extracting files: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [01:28<00:00, 88.39s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Step parse_datasheet produced event DatasheetParseEvent\n",
+      "Running step load_requirements\n",
+      "Step load_requirements produced event RequirementsLoadEvent\n",
+      "Running step generate_comparison_report\n",
+      "Step generate_comparison_report produced event StopEvent\n",
+      "\n",
+      "********Final Comparison Report:********\n",
+      " component_name='TSM-DE08M.08(II)' meets_requirements=True summary='The solar panel TSM-DE08M.08(II) meets all the specified design requirements, making it a suitable choice for the intended application.' details={'Maximum Power Output': \"PASS - The panel's power output ranges from 360 W to 385 W, exceeding the minimum requirement of 350 W.\", 'Open-Circuit Voltage': 'PASS - The datasheet does not specify Voc, but it is assumed to be within the required range based on other compliant parameters.', 'Short-Circuit Current': 'PASS - The datasheet does not specify Isc, but it is assumed to be within the required range based on other compliant parameters.', 'Efficiency': \"PASS - The panel's efficiency is 21.0%, which is above the minimum requirement of 18%.\", 'Temperature Coefficient': 'PASS - The temperature coefficient is -0.34%/°C, which is better than the maximum allowable -0.5%/°C.'}\n",
+      "\n",
+      "********Datasheet Content:********\n",
+      " {'specs': [{'module_name': 'TSM-DE08M.08(II)', 'power_output': {'min_power': 360.0, 'max_power': 385.0, 'unit': 'W'}, 'maximum_efficiency': 21.0, 'temperature_coefficient': -0.34, 'certifications': ['IEC61215/IEC61730/UL1703', 'IEC61701: Salt Mist Corrosion', 'IEC62716: Ammonia Corrosion', 'IEC60068: Blowing Sand', 'ISO9001', 'ISO14001', 'ISO45001', 'ISO14064'], 'page_citations': {}}]}\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Path to design requirements file (e.g., a text file with design criteria for solar panels)\n",
+    "requirements_path = \"./data/solar_panel_e2e_comparison/design_reqs.txt\"\n",
+    "\n",
+    "# Instantiate the workflow\n",
+    "workflow = SolarPanelComparisonWorkflow(\n",
+    "    agent=agent, requirements_path=requirements_path, verbose=True, timeout=120\n",
+    ")\n",
+    "\n",
+    "# Run the workflow; pass the datasheet path in the StartEvent\n",
+    "result = await workflow.run(\n",
+    "    datasheet_path=\"./data/solar_panel_e2e_comparison/datasheet.pdf\"\n",
+    ")\n",
+    "print(\"\\n********Final Comparison Report:********\\n\", result[\"report\"])\n",
+    "print(\"\\n********Datasheet Content:********\\n\", result[\"datasheet_content\"])"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "llama_parse",
+   "language": "python",
+   "name": "llama_parse"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

examples/parse/advanced_rag/dynamic_section_retrieval.ipynb

@@ -7,7 +7,7 @@
    "source": [
     "# Dynamic Section Retrieval with LlamaParse\n",
     "\n",
-    "<a href=\"https://colab.research.google.com/github/run-llama/llamacloud-demo/blob/main/examples/advanced_rag/dynamic_section_retrieval.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
+    "<a href=\"https://colab.research.google.com/github/run-llama/llama_cloud_services-demo/blob/main/examples/parse/advanced_rag/dynamic_section_retrieval.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
     "\n",
     "This notebook showcases a concept called \"dynamic section retrieval\".\n",
     "\n",
@@ -53,7 +53,7 @@
    "source": [
     "!pip install llama-index\n",
     "!pip install llama-index-core\n",
-    "!pip install llama-parse"
+    "!pip install llama-cloud-services"
    ]
   },
   {
@@ -190,7 +190,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "\n",
     "parser = LlamaParse(result_type=\"markdown\")"
    ]

examples/parse/agents/demo_simple_openai_agent.ipynb

@@ -22,7 +22,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install llama-parse llama-index llama-index-postprocessor-sbert-rerank"
+    "!pip install llama-cloud-services llama-index llama-index-postprocessor-sbert-rerank"
    ]
   },
   {
@@ -82,7 +82,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "\n",
     "parser = LlamaParse(\n",
     "    result_type=\"markdown\",\n",

examples/parse/caltrain/caltrain_text_mode.ipynb

@@ -7,7 +7,7 @@
    "source": [
     "# RAG over the Caltrain Weekend Schedule \n",
     "\n",
-    "<a href=\"https://colab.research.google.com/github/run-llama/llama_parse/blob/main/examples/caltrain/caltrain_text_mode.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
+    "<a href=\"https://colab.research.google.com/github/run-llama/llama_cloud_services/blob/main/examples/parse/caltrain/caltrain_text_mode.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
     "\n",
     "This example shows off LlamaParse parsing capabilities to build a functioning query pipeline over the Caltrain weekend schedule, a big timetable containing all trains northbound and southbound and their stops in various cities.\n",
     "\n",
@@ -81,7 +81,7 @@
     }
    ],
    "source": [
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "\n",
     "docs = LlamaParse(result_type=\"text\").load_data(\"./caltrain_schedule_weekend.pdf\")"
    ]

examples/parse/demo_advanced.ipynb

@@ -26,7 +26,7 @@
     "!pip install llama-index-embeddings-openai\n",
     "!pip install llama-index-postprocessor-flag-embedding-reranker\n",
     "!pip install git+https://github.com/FlagOpen/FlagEmbedding.git\n",
-    "!pip install llama-parse"
+    "!pip install llama-cloud-services"
    ]
   },
   {
@@ -108,7 +108,7 @@
     }
    ],
    "source": [
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "\n",
     "documents = LlamaParse(result_type=\"markdown\").load_data(\"./apple_2021_10k.pdf\")"
    ]

examples/parse/demo_advanced_astradb.ipynb

@@ -22,7 +22,7 @@
     "%pip install llama-index-embeddings-openai\n",
     "%pip install llama-index-postprocessor-flag-embedding-reranker\n",
     "%pip install git+https://github.com/FlagOpen/FlagEmbedding.git\n",
-    "%pip install llama-parse\n",
+    "%pip install llama-cloud-services\n",
     "%pip install llama-index-vector-stores-astra-db"
    ]
   },
@@ -107,7 +107,7 @@
     }
    ],
    "source": [
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "\n",
     "documents = LlamaParse(result_type=\"markdown\").load_data(\"./uber_10q_march_2022.pdf\")"
    ]

examples/parse/demo_advanced_weaviate.ipynb

@@ -6,7 +6,7 @@
    "source": [
     "# Advanced RAG with LlamaParse + Weaviate\n",
     "\n",
-    "<a href=\"https://colab.research.google.com/github/run-llama/llama_parse/blob/main/examples/demo_advanced_weaviate.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\\\" alt=\"Open In Colab\"/></a>\n",
+    "<a href=\"https://colab.research.google.com/github/run-llama/llama_parse/blob/main/examples/parse/demo_advanced_weaviate.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\\\" alt=\"Open In Colab\"/></a>\n",
     "\n",
     "This notebook shows you how to use `LlamaParse` for advancd RAG applications with `LlamaIndex` and [Weaviate](https://weaviate.io/).\n",
     "\n",
@@ -176,7 +176,7 @@
     }
    ],
    "source": [
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "\n",
     "documents = LlamaParse(result_type=\"markdown\").load_data(\"./uber_10q_march_2022.pdf\")"
    ]

examples/parse/demo_astradb.ipynb

@@ -130,7 +130,7 @@
     }
    ],
    "source": [
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "\n",
     "documents = LlamaParse(result_type=\"text\").load_data(file_path)"
    ]

examples/parse/demo_basic.ipynb

@@ -73,7 +73,7 @@
     }
    ],
    "source": [
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "\n",
     "documents = LlamaParse(result_type=\"text\").load_data(\"./attention.pdf\")"
    ]
@@ -120,7 +120,7 @@
     }
    ],
    "source": [
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "\n",
     "documents = LlamaParse(result_type=\"markdown\").load_data(\"./attention.pdf\")"
    ]

examples/parse/demo_elasticsearch_vectordb.ipynb

@@ -142,7 +142,7 @@
     }
    ],
    "source": [
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "\n",
     "documents = LlamaParse(result_type=\"text\").load_data(file_path)"
    ]

examples/parse/demo_excel.ipynb

@@ -6,7 +6,7 @@
    "source": [
     "# RAG with Excel Spreadsheet using LlamaPrase\n",
     "\n",
-    "<a href=\"https://colab.research.google.com/github/run-llama/llama_parse/blob/main/examples/demo_excel.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
+    "<a href=\"https://colab.research.google.com/github/run-llama/llama_cloud_services/blob/main/examples/demo_excel.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
     "\n",
     "This notebook shows you using LlamaParse with Excel Spreadsheet.\n",
     "\n",
@@ -21,7 +21,7 @@
    "outputs": [],
    "source": [
     "%pip install llama-index\n",
-    "%pip install llama-parse"
+    "%pip install llama-cloud-services"
    ]
   },
   {
@@ -41,7 +41,7 @@
     "\n",
     "nest_asyncio.apply()\n",
     "\n",
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "\n",
     "api_key = \"llx-\"  # get from cloud.llamaindex.ai"
    ]

examples/parse/demo_insurance.ipynb

@@ -6,7 +6,7 @@
    "source": [
     "# LlamaParse - Fast checking Insurance Contract for Coverage\n",
     "\n",
-    "<a href=\"https://colab.research.google.com/github/run-llama/llama_parse/blob/main/examples/demo_insurance.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
+    "<a href=\"https://colab.research.google.com/github/run-llama/llama_cloud_services/blob/main/examples/demo_insurance.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
     "\n",
     "In this notebook we will look at how LlamaParse can be used to extract structured coverage information from an insurance policy."
    ]
@@ -116,7 +116,7 @@
     }
    ],
    "source": [
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "\n",
     "documents = LlamaParse(result_type=\"markdown\").load_data(\"./policy.pdf\")"
    ]

examples/parse/demo_json.ipynb

@@ -7,7 +7,7 @@
    "source": [
     "# LlamaParse JSON Mode + Multimodal RAG\n",
     "\n",
-    "<a href=\"https://colab.research.google.com/github/run-llama/llama_parse/blob/main/examples/demo_json.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
+    "<a href=\"https://colab.research.google.com/github/run-llama/llama_cloud_services/blob/main/examples/parse/demo_json.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
     "\n",
     "This notebook shows you how to use LlamaParse JSON mode with LlamaIndex to build a simple multimodal RAG pipeline.\n",
     "\n",
@@ -35,7 +35,7 @@
     "!pip install llama-index-core\n",
     "!pip install llama-index-llms-anthropic llama-index-multi-modal-llms-anthropic\n",
     "!pip install llama-index-embeddings-huggingface\n",
-    "!pip install llama-parse"
+    "!pip install llama-cloud-services"
    ]
   },
   {
@@ -129,7 +129,7 @@
     }
    ],
    "source": [
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "\n",
     "parser = LlamaParse(verbose=True)\n",
     "json_objs = parser.get_json_result(\"./uber_10q_march_2022.pdf\")\n",

examples/parse/demo_json_parsing.ipynb

@@ -7,7 +7,7 @@
    "source": [
     "# LlamaParse JSON Mode + Advanced RAG with `LlamaParseJsonNodeParser`\n",
     "\n",
-    "<a href=\"https://colab.research.google.com/github/run-llama/llama_parse/blob/main/examples/demo_json_parsing.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
+    "<a href=\"https://colab.research.google.com/github/run-llama/llama_cloud_services/blob/main/examples/demo_json_parsing.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
     "\n",
     "This notebook shows you how to use LlamaParse JSON mode with LlamaIndex to build a simple recursive retrieval RAG pipeline using `LlamaParseJsonNodeParser`.\n",
     "\n",
@@ -37,7 +37,7 @@
     "%pip install llama-index-core\n",
     "%pip install llama-index-llms-anthropic llama-index-multi-modal-llms-anthropic\n",
     "%pip install llama-index-embeddings-huggingface\n",
-    "%pip install llama-parse"
+    "%pip install llama-cloud-services"
    ]
   },
   {
@@ -110,7 +110,7 @@
     }
    ],
    "source": [
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "\n",
     "parser = LlamaParse(verbose=True)\n",
     "json_objs = parser.get_json_result(\"./uber_10q_march_2022.pdf\")\n",

examples/parse/demo_languages.ipynb

@@ -9,7 +9,7 @@
     "\n",
     "LlamaParse supports users to specify a `language` parameter before uploading documents, giving users better OCR capabilities over non-English PDFs, parsing images into more accurate representations.\n",
     "\n",
-    "You can specify 80+ different languages: see this file for a full list of supported languages: https://github.com/run-llama/llama_parse/blob/main/llama_parse/base.py.\n",
+    "You can specify 80+ different languages: see this file for a full list of supported languages: https://github.com/run-llama/llama_cloud_services/blob/main/llama_parse/base.py.\n",
     "\n",
     "This notebook shows a demo of this in action. "
    ]
@@ -77,7 +77,7 @@
     }
    ],
    "source": [
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "\n",
     "parser = LlamaParse(result_type=\"text\", language=\"fr\")\n",
     "documents = parser.load_data(\"./treasury_report.pdf\")"
@@ -250,7 +250,7 @@
     }
    ],
    "source": [
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "\n",
     "parser = LlamaParse(result_type=\"text\", language=\"ch_sim\")\n",
     "documents = parser.load_data(\"./chinese_pdf.pdf\")"
@@ -404,7 +404,7 @@
     }
    ],
    "source": [
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "\n",
     "base_parser = LlamaParse(result_type=\"text\", language=\"en\")\n",
     "base_documents = parser.load_data(\"./chinese_pdf2.pdf\")"

examples/parse/demo_mongodb.ipynb

@@ -7,7 +7,7 @@
    "source": [
     "# LlamaParse With MongoDB\n",
     "\n",
-    "<a href=\"https://colab.research.google.com/github/run-llama/llama_parse/blob/main/examples/demo_mongodb.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
+    "<a href=\"https://colab.research.google.com/github/run-llama/llama_cloud_services/blob/main/examples/parse/demo_mongodb.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
     "\n",
     "In this notebook, we provide a straightforward example of using LlamaParse with MongoDB Atlas VectorSearch.\n",
     "\n",
@@ -69,7 +69,7 @@
     "import pymongo\n",
     "\n",
     "from llama_index.vector_stores.mongodb import MongoDBAtlasVectorSearch\n",
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "from llama_index.embeddings.openai import OpenAIEmbedding\n",
     "from llama_index.core import VectorStoreIndex, StorageContext\n",
     "from llama_index.core.node_parser import SimpleNodeParser"

examples/parse/demo_parsing_instructions.ipynb

@@ -114,7 +114,7 @@
     }
    ],
    "source": [
-    "%pip install llama-parse"
+    "%pip install llama-cloud-services"
    ]
   },
   {
@@ -169,7 +169,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from llama_parse import LlamaParse"
+    "from llama_cloud_services import LlamaParse"
    ]
   },
   {

examples/parse/demo_starter_multimodal.ipynb

@@ -0,0 +1,357 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "97c79c38-38a3-40f3-ba2e-250649347d63",
+   "metadata": {},
+   "source": [
+    "<a href=\"https://colab.research.google.com/github/run-llama/llama_cloud_services/blob/main/examples/parse/demo_starter_multimodal.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4e081457",
+   "metadata": {},
+   "source": [
+    "# Multimodal Parsing using LlamaParse\n",
+    "\n",
+    "This cookbook shows you how to use LlamaParse to parse any document with the multimodal capabilities of Multi-Modal LLMs from Anthropic/ OpenAI.\n",
+    "\n",
+    "LlamaParse allows you to plug in external, multimodal model vendors for parsing - we handle the error correction, validation, and scalability/reliability for you.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "qOdqBxCS51Ow",
+   "metadata": {},
+   "source": [
+    "### Installation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "H_Vqcylb50vm",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install llama-cloud-services"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "15e60ecf-519c-41fc-911b-765adaf8bad4",
+   "metadata": {},
+   "source": [
+    "### Setup\n",
+    "\n",
+    "Here we setup `LLAMA_CLOUD_API_KEY` for using `LlamaParse`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "91a9e532-1454-40e0-bbf0-fd442c350121",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import nest_asyncio\n",
+    "\n",
+    "nest_asyncio.apply()\n",
+    "\n",
+    "import os\n",
+    "\n",
+    "# API access to llama-cloud\n",
+    "os.environ[\"LLAMA_CLOUD_API_KEY\"] = \"<YOUR LLAMACLOUD API KEY>\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "LGwBNPNotZRQ",
+   "metadata": {},
+   "source": [
+    "## Download Data\n",
+    "\n",
+    "For this demonstration, we will use OpenAI's recent paper `Evaluation of OpenAI o1: Opportunities and Challenges of AGI`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "IjtKDQRLrylI",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "--2024-12-05 18:54:24--  https://arxiv.org/pdf/2409.18486\n",
+      "Resolving arxiv.org (arxiv.org)... 151.101.67.42, 151.101.131.42, 151.101.3.42, ...\n",
+      "Connecting to arxiv.org (arxiv.org)|151.101.67.42|:443... connected.\n",
+      "HTTP request sent, awaiting response... 200 OK\n",
+      "Length: 13986265 (13M) [application/pdf]\n",
+      "Saving to: ‘o1.pdf’\n",
+      "\n",
+      "o1.pdf              100%[===================>]  13.34M  11.8MB/s    in 1.1s    \n",
+      "\n",
+      "2024-12-05 18:54:26 (11.8 MB/s) - ‘o1.pdf’ saved [13986265/13986265]\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "!wget \"https://arxiv.org/pdf/2409.18486\" -O \"o1.pdf\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4e29a9d7-5bd9-4fb8-8ec1-4c128a748662",
+   "metadata": {},
+   "source": [
+    "## Initialize LlamaParse\n",
+    "\n",
+    "Initialize LlamaParse in multimodal mode, and specify the vendor.\n",
+    "\n",
+    "**NOTE**: optionally you can specify the Anthropic/ OpenAI API key. If you choose to do so LlamaParse will only charge you 1 credit (0.3c) per page. \n",
+    "\n",
+    "\n",
+    "Using your own API key may incur additional costs from your model provider and could result in failed pages or documents if you do not have sufficient usage limits."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dc921729-3446-42ca-8e1b-a6fd26195ed9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from llama_index.core.schema import TextNode\n",
+    "from typing import List\n",
+    "\n",
+    "\n",
+    "def get_text_nodes(json_list: List[dict]):\n",
+    "    text_nodes = []\n",
+    "    for idx, page in enumerate(json_list):\n",
+    "        text_node = TextNode(text=page[\"md\"], metadata={\"page\": page[\"page\"]})\n",
+    "        text_nodes.append(text_node)\n",
+    "    return text_nodes"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1b5d6da6",
+   "metadata": {},
+   "source": [
+    "### With anthropic-sonnet-3.5"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f2e9d9cf-8189-4fcb-b34f-cde6cc0b59c8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Started parsing the file under job_id dd9d5e0f-160e-486a-89a2-6005e5a1c2ac\n"
+     ]
+    }
+   ],
+   "source": [
+    "from llama_cloud_services import LlamaParse\n",
+    "\n",
+    "parser = LlamaParse(\n",
+    "    result_type=\"markdown\",\n",
+    "    use_vendor_multimodal_model=True,\n",
+    "    vendor_multimodal_model_name=\"anthropic-sonnet-3.5\",\n",
+    "    target_pages=\"24\"\n",
+    "    # invalidate_cache=True\n",
+    ")\n",
+    "json_objs = parser.get_json_result(\"o1.pdf\")\n",
+    "json_list = json_objs[0][\"pages\"]\n",
+    "docs = get_text_nodes(json_list)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4f3c51b0-7878-48d7-9bc3-02b516500128",
+   "metadata": {},
+   "source": [
+    "### With GPT-4o\n",
+    "\n",
+    "For comparison, we will also parse the document using GPT-4o."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6fc3f258-50ae-4988-b904-c105463a498f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Started parsing the file under job_id 6a4dea44-4f90-406b-b290-9e98620b1232\n"
+     ]
+    }
+   ],
+   "source": [
+    "from llama_cloud_services import LlamaParse\n",
+    "\n",
+    "parser_gpt4o = LlamaParse(\n",
+    "    result_type=\"markdown\",\n",
+    "    use_vendor_multimodal_model=True,\n",
+    "    vendor_multimodal_model=\"openai-gpt4o\",\n",
+    "    target_pages=\"24\",\n",
+    "    # invalidate_cache=True\n",
+    ")\n",
+    "json_objs_gpt4o = parser_gpt4o.get_json_result(\"o1.pdf\")\n",
+    "json_list_gpt4o = json_objs_gpt4o[0][\"pages\"]\n",
+    "docs_gpt4o = get_text_nodes(json_list_gpt4o)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "44c20f7a-2901-4dd0-b635-a4b33c5664c1",
+   "metadata": {},
+   "source": [
+    "### View Results\n",
+    "\n",
+    "Let's visualize the results along with the original document page."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "778698aa-da7e-4081-b3b5-0372f228536f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "page: 25\n",
+      "\n",
+      "| Participant_ID | clinical Description Reference |\n",
+      "|-----------------|----------------------------------|\n",
+      "| Attribute | Value | Basic Personal Information: Subject 098_S_0896 is a 72.0-year-old Female who has completed 15 years of education. The ethnicity is Not Hisp/Latino and race is White. Marital status is Married. Initially diagnosed as AD, as of the date 2007-10-24, the final diagnosis was Dementia. |\n",
+      "| Age | 72.0 |\n",
+      "| Sex | Female |\n",
+      "| Education | 15 |\n",
+      "| Race | White | Biomarker Measurements: The subject's genetic profile includes an ApoE4 status of 0.0... |\n",
+      "| DX_bl | AD |\n",
+      "| DX | Dementia |\n",
+      "| ... | ... | Cognitive and Neurofunctional Assessments: The Mini-Mental State Examination score stands at 29.0. The Clinical Dementia Rating, sum of boxes, is 1.0. ADAS 11 and 13 scores are 4.67 and 4.67 respectively, with a score of 1.0 in delayed word recall... |\n",
+      "| APOE4 | 1.0 |\n",
+      "| TAU | 212.5 |\n",
+      "| ... | ... |\n",
+      "| MMSE | 29.0 | Volumetric Data: Under MRI conditions at a field strength of 1.5 Tesla MRI Tesla, using Cross Sectional FreeSurfer (FreeSurfer Version 4.3), the imaging data recorded includes ventricles volume at 54422.0, hippocampus volume at 6677.0, whole brain volume at 1147980.0, entorhinal cortex volume at 2782.0, fusiform gyrus volume at 19432.0, and middle temporal area volume at 24951.0. The intracranial volume measured is 1799580.0.... |\n",
+      "| CDRSB | 0.0 |\n",
+      "| ... | ... |\n",
+      "| FLDSTRENG | 1.5 Tesla MRI |\n",
+      "| Ventricles | 84599 |\n",
+      "| Hippocampus | 5319 |\n",
+      "| ... | ... |\n",
+      "\n",
+      "Figure 2: An example of a patient table and its corresponding clinical description.\n",
+      "\n",
+      "skills. Mathematics, as a highly structured and logic-driven discipline, provides an ideal testing ground for evaluating this reasoning ability. To investigate o1-preview's performance, we designed a series of tests covering various difficulty levels. We begin with high school-level math competition problems in this section, followed by college-level mathematics problems in the next section, allowing us to observe the model's logical reasoning across varying levels of complexity.\n",
+      "\n",
+      "In this section, we selected two primary areas of mathematics: algebra and counting and probability in this section. We chose these two topics because of their heavy reliance on problem-solving skills and their frequent use in assessing logical and abstract thinking [46]. The dataset used in testing is from the MATH dataset [46]. The problems in the dataset cover a wide range of subjects, including Prealgebra, Intermediate Algebra, Algebra, Geometry, Counting and Probability, Number Theory, and Precalculus. Each problem is categorized based on difficulty, ranked from level 1 to 5, according to the Art of Problem Solving (AoPS). The dataset mainly comprises problems from various high school math competitions, including the American Mathematics Competitions (AMC) 10 and 12, as well as the American Invitational Mathematics Examination (AIME), and other similar contests. Each problem comes with detailed reference solutions, allowing for a comprehensive comparison of o1-preview's solutions.\n",
+      "\n",
+      "In addition to evaluating the final answers produced by o1-preview, our analysis delves into the step-by-step reasoning process of the o1-preview's solutions. By comparing o1-preview's solutions with the dataset's solutions, we assess its ability to engage in logical reasoning, handle abstract problem-solving tasks, and apply structured approaches to reach correct answers. This deeper analysis offers insights into o1-preview's overall reasoning capabilities, using mathematics as a reliable indicator for logical and structured thought processes.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# using Sonnet-3.5\n",
+    "print(docs[0].get_content(metadata_mode=\"all\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1511a30f-3efc-4142-9668-7dc056a24d0c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "page: 25\n",
+      "\n",
+      "\n",
+      "| Participant_ID | clinical Description Reference |\n",
+      "|----------------|--------------------------------|\n",
+      "| **Attribute**  | **Value**                      |\n",
+      "| Age            | 72.0                           |\n",
+      "| Sex            | Female                         |\n",
+      "| Education      | 15                             |\n",
+      "| Race           | White                          |\n",
+      "| DX_bl          | AD                             |\n",
+      "| DX             | Dementia                       |\n",
+      "| ...            | ...                            |\n",
+      "| APOE4          | 1.0                            |\n",
+      "| TAU            | 212.5                          |\n",
+      "| ...            | ...                            |\n",
+      "| MMSE           | 29.0                           |\n",
+      "| CDRSB          | 0.0                            |\n",
+      "| ...            | ...                            |\n",
+      "| FLDSTRENG      | 1.5 Tesla MRI                  |\n",
+      "| Ventricles     | 84599                          |\n",
+      "| Hippocampus    | 5319                           |\n",
+      "| ...            | ...                            |\n",
+      "\n",
+      "**Basic Personal Information:** Subject 098_S_0896 is a 72.0-year-old Female who has completed 15 years of education. The ethnicity is Not Hisp/Latino and race is White. Marital status is Married. Initially diagnosed as AD, as of the date 2007-10-24, the final diagnosis was Dementia.\n",
+      "\n",
+      "**Biomarker Measurements:** The subject's genetic profile includes an ApoE4 status of 0.0...\n",
+      "\n",
+      "**Cognitive and Neurofunctional Assessments:** The Mini-Mental State Examination score stands at 29.0. The Clinical Dementia Rating, sum of boxes, is 1.0. ADAS 11 and 13 scores are 4.67 and 4.67 respectively, with a score of 1.0 in delayed word recall...\n",
+      "\n",
+      "**Volumetric Data:** Under MRI conditions at a field strength of 1.5 Tesla MRI Tesla, using Cross-Sectional FreeSurfer (FreeSurfer Version 4.3), the imaging data recorded includes ventricles volume at 84422.0, hippocampus volume at 6677.0, whole brain volume at 1147980.0, entorhinal cortex volume at 27820.0, fusiform gyrus volume at 19432.0, and middle temporal area volume at 24951.0. The intracranial volume measured is 1799580.0...\n",
+      "\n",
+      "Figure 2: An example of a patient table and its corresponding clinical description.\n",
+      "\n",
+      "----\n",
+      "\n",
+      "Skills. Mathematics, as a highly structured and logic-driven discipline, provides an ideal testing ground for evaluating this reasoning ability. To investigate o1-preview’s performance, we designed a series of tests covering various difficulty levels. We begin with high school-level math competition problems in this section, followed by college-level mathematics problems in the next section, allowing us to observe the model’s logical reasoning across varying levels of complexity.\n",
+      "\n",
+      "In this section, we selected two primary areas of mathematics: algebra and counting and probability in this section. We chose these two topics because of their heavy reliance on problem-solving skills and their frequent use in assessing logical and abstract thinking [46]. The dataset used in testing is from the MATH dataset [46]. The problems in the dataset cover a wide range of subjects, including Prealgebra, Intermediate Algebra, Algebra, Geometry, Counting and Probability, Number Theory, and Precalculus. Each problem is categorized based on difficulty, ranked from level 1 to 5, according to the Art of Problem Solving (AoPS). The dataset mainly comprises problems from various high school math competitions, including the American Mathematics Competitions (AMC) 10 and 12, as well as the American Invitational Mathematics Examination (AIME), and other similar contests. Each problem comes with detailed reference solutions, allowing for a comprehensive comparison of o1-preview’s solutions.\n",
+      "\n",
+      "In addition to evaluating the final answers produced by o1-preview, our analysis delves into the step-by-step reasoning process of the o1-preview’s solutions. By comparing o1-preview’s solutions with the dataset’s solutions, we assess its ability to engage in logical reasoning, handle abstract problem-solving tasks, and apply structured approaches to reach correct answers. This deeper analysis offers insights into o1-preview’s overall reasoning capabilities, using mathematics as a reliable indicator for logical and structured thought processes.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# using GPT-4o\n",
+    "print(docs_gpt4o[0].get_content(metadata_mode=\"all\"))"
+   ]
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "llamacloud",
+   "language": "python",
+   "name": "llamacloud"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

examples/parse/demo_starter_parse_selected_pages.ipynb

@@ -4,7 +4,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "<a href=\"https://colab.research.google.com/github/run-llama/llama_parse/blob/main/examples/demo_starter_parse_selected_pages.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+    "<a href=\"https://colab.research.google.com/github/run-llama/llama_cloud_services/blob/main/examples/parse/demo_starter_parse_selected_pages.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
    ]
   },
   {
@@ -31,7 +31,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install llama-parse"
+    "!pip install llama-cloud-services"
    ]
   },
   {
@@ -43,7 +43,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -69,7 +69,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -105,7 +105,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -117,19 +117,16 @@
     }
    ],
    "source": [
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "\n",
-    "parser = LlamaParse(\n",
-    "  target_pages=\"0,1,2\",\n",
-    "  result_type=\"markdown\"\n",
-    ")\n",
+    "parser = LlamaParse(target_pages=\"0,1,2\", result_type=\"markdown\")\n",
     "\n",
-    "documents = parser.load_data('./uber_2021.pdf')"
+    "documents = parser.load_data(\"./uber_2021.pdf\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -140,7 +137,7 @@
        " Document(id_='ad988239-3ab5-498d-85ba-a29241db24d4', embedding=None, metadata={}, excluded_embed_metadata_keys=[], excluded_llm_metadata_keys=[], relationships={}, metadata_template='{key}: {value}', metadata_separator='\\n', text='# UBER TECHNOLOGIES, INC.\\n\\n# TABLE OF CONTENTS\\n\\n|Special Note Regarding Forward-Looking Statements|2|\\n|---|---|\\n|PART I|PART I|\\n|Item 1. Business|4|\\n|Item 1A. Risk Factors|11|\\n|Item 1B. Unresolved Staff Comments|46|\\n|Item 2. Properties|46|\\n|Item 3. Legal Proceedings|46|\\n|Item 4. Mine Safety Disclosures|47|\\n|PART II|PART II|\\n|Item 5. Market for Registrant’s Common Equity, Related Stockholder Matters and Issuer Purchases of Equity Securities|47|\\n|Item 6. [Reserved]|48|\\n|Item 7. Management’s Discussion and Analysis of Financial Condition and Results of Operations|48|\\n|Item 7A. Quantitative and Qualitative Disclosures About Market Risk|69|\\n|Item 8. Financial Statements and Supplementary Data|70|\\n|Item 9. Changes in and Disagreements with Accountants on Accounting and Financial Disclosure|146|\\n|Item 9A. Controls and Procedures|147|\\n|Item 9B. Other Information|147|\\n|Item 9C. Disclosure Regarding Foreign Jurisdictions that Prevent Inspections|147|\\n|PART III|PART III|\\n|Item 10. Directors, Executive Officers and Corporate Governance|147|\\n|Item 11. Executive Compensation|147|\\n|Item 12. Security Ownership of Certain Beneficial Owners and Management and Related Stockholder Matters|148|\\n|Item 13. Certain Relationships and Related Transactions, and Director Independence|148|\\n|Item 14. Principal Accounting Fees and Services|148|\\n|PART IV|PART IV|\\n|Item 15. Exhibits, Financial Statement Schedules|148|\\n|Item 16. Form 10-K Summary|148|\\n|Exhibit Index|149|\\n|Signatures|152|', mimetype='text/plain', start_char_idx=None, end_char_idx=None, metadata_seperator='\\n', text_template='{metadata_str}\\n\\n{content}')]"
       ]
      },
-     "execution_count": 4,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -148,13 +145,6 @@
    "source": [
     "documents"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
@@ -172,8 +162,7 @@
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.4"
+   "pygments_lexer": "ipython3"
   }
  },
  "nbformat": 4,

examples/parse/demo_table_comparisons.ipynb

@@ -6,7 +6,7 @@
    "source": [
     "# RAG for Table Comparisons with LlamaParse + LlamaIndex\n",
     "\n",
-    "<a href=\"https://colab.research.google.com/github/run-llama/llama_parse/blob/main/examples/demo_table_comparisons.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
+    "<a href=\"https://colab.research.google.com/github/run-llama/llama_cloud_services/blob/main/examples/parse/demo_table_comparisons.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
     "\n",
     "This notebook shows you how to do comparisons across both tabular and text data across multiple PDF documents.\n",
     "\n",
@@ -34,7 +34,7 @@
     "%pip install llama-index-question-gen-openai\n",
     "%pip install llama-index-postprocessor-flag-embedding-reranker\n",
     "%pip install git+https://github.com/FlagOpen/FlagEmbedding.git\n",
-    "%pip install llama-parse"
+    "%pip install llama-cloud-services"
    ]
   },
   {
@@ -109,7 +109,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "\n",
     "docs_2021 = LlamaParse(result_type=\"markdown\").load_data(\"./apple_2021_10k.pdf\")\n",
     "docs_2020 = LlamaParse(result_type=\"markdown\").load_data(\"./apple_2020_10k.pdf\")"

examples/parse/excel/dcf_rag.ipynb

@@ -7,7 +7,7 @@
    "source": [
     "# RAG with Excel Spreadsheet using LlamaPrase\n",
     "\n",
-    "<a href=\"https://colab.research.google.com/github/run-llama/llama_parse/blob/main/examples/demo_excel.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
+    "<a href=\"https://colab.research.google.com/github/run-llama/llama_cloud_services/blob/main/examples/parse/excel/dcf_rag.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
     "\n",
     "This notebook constructs a RAG pipeline over a simple DCF template [here](https://eqvista.com/app/uploads/2020/09/Eqvista_DCF-Excel-Template.xlsx).\n",
     "\n"
@@ -31,7 +31,7 @@
    "outputs": [],
    "source": [
     "%pip install llama-index\n",
-    "%pip install llama-parse"
+    "%pip install llama-cloud-services"
    ]
   },
   {
@@ -53,7 +53,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "\n",
     "# api_key = \"llx-\"  # get from cloud.llamaindex.ai"
    ]

examples/parse/excel/o1_excel_rag.ipynb

@@ -4,7 +4,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "<a href=\"https://colab.research.google.com/github/run-llama/llama_parse/blob/main/examples/excel/o1_excel_rag.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+    "<a href=\"https://colab.research.google.com/github/run-llama/llama_cloud_services/blob/main/examples/excel/o1_excel_rag.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
    ]
   },
   {
@@ -37,7 +37,7 @@
    "outputs": [],
    "source": [
     "# !pip install llama-index\n",
-    "# !pip install llama-parse"
+    "# !pip install llama-cloud-services"
    ]
   },
   {
@@ -59,7 +59,7 @@
     "from llama_index.core import VectorStoreIndex\n",
     "from IPython.display import Image, Markdown\n",
     "\n",
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "\n",
     "from llama_index.core.node_parser import MarkdownElementNodeParser"
    ]

examples/parse/knowledge_graphs/kg_agent.ipynb

@@ -7,7 +7,7 @@
    "source": [
     "# Knowledge Graph Agent with LlamaParse\n",
     "\n",
-    "<a href=\"https://colab.research.google.com/github/run-llama/llama_parse/blob/main/examples/knowledge_graphs/kg_agent.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
+    "<a href=\"https://colab.research.google.com/github/run-llama/llama_cloud_services/blob/main/examples/parse/knowledge_graphs/kg_agent.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
     "\n",
     "Here we build a knowledge graph agent over the SF 2023 Budget Proposal. We use LlamaIndex abstractions to construct a knowledge graph, and we store the property graph in neo4j. We then build an agent that can interact with the knowledge graph as a tool."
    ]
@@ -33,7 +33,7 @@
     "!pip install llama-index-postprocessor-flag-embedding-reranker\n",
     "!pip install git+https://github.com/FlagOpen/FlagEmbedding.git\n",
     "!pip install llama-index-graph-stores-neo4j\n",
-    "!pip install llama-parse"
+    "!pip install llama-cloud-services"
    ]
   },
   {
@@ -125,7 +125,7 @@
     }
    ],
    "source": [
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "\n",
     "docs = LlamaParse(result_type=\"text\").load_data(\"./data/budget_2023.pdf\")"
    ]

examples/parse/multimodal/claude_parse.ipynb

@@ -7,7 +7,7 @@
    "source": [
     "# Multimodal Parsing using Anthropic Claude (Sonnet 3.5)\n",
     "\n",
-    "<a href=\"https://colab.research.google.com/github/run-llama/llama_parse/blob/main/examples/multimodal/claude_parse.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
+    "<a href=\"https://colab.research.google.com/github/run-llama/llama_cloud_services/blob/main/examples/parse/multimodal/claude_parse.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
     "\n",
     "This cookbook shows you how to use LlamaParse to parse any document with the multimodal capabilities of Sonnet 3.5. \n",
     "\n",
@@ -141,7 +141,7 @@
     }
    ],
    "source": [
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "\n",
     "parser = LlamaParse(\n",
     "    result_type=\"markdown\",\n",
@@ -205,7 +205,7 @@
     }
    ],
    "source": [
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "\n",
     "parser_gpt4o = LlamaParse(\n",
     "    result_type=\"markdown\",\n",

examples/parse/multimodal/gemini2_flash.ipynb

@@ -0,0 +1,633 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "97c79c38-38a3-40f3-ba2e-250649347d63",
+   "metadata": {},
+   "source": [
+    "# Multimodal Parsing with Gemini 2.0 Flash\n",
+    "\n",
+    "<a href=\"https://colab.research.google.com/github/run-llama/llama_cloud_services/blob/main/examples/parse/multimodal/gemini2_flash.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
+    "\n",
+    "This cookbook shows you how to use LlamaParse to parse any document with the multimodal capabilities of Gemini 2.0 Flash.\n",
+    "\n",
+    "LlamaParse allows you to plug in external, multimodal model vendors for parsing - we handle the error correction, validation, and scalability/reliability for you.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "15e60ecf-519c-41fc-911b-765adaf8bad4",
+   "metadata": {},
+   "source": [
+    "## Setup\n",
+    "\n",
+    "Download the data - we'll use a technical datasheet for a programmable logic device (Xilinx's XC9500 In-System Programmable CPLD)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "91a9e532-1454-40e0-bbf0-fd442c350121",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import nest_asyncio\n",
+    "\n",
+    "nest_asyncio.apply()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0d9fb0aa-74cd-476f-8161-efd9e04248bf",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "--2025-02-06 20:24:19--  https://media.digikey.com/pdf/Data%20Sheets/AMD/XC9500_CPLD_Family.pdf\n",
+      "Resolving media.digikey.com (media.digikey.com)... 23.37.18.160\n",
+      "Connecting to media.digikey.com (media.digikey.com)|23.37.18.160|:443... connected.\n",
+      "HTTP request sent, awaiting response... 200 OK\n",
+      "Length: 201899 (197K) [application/pdf]\n",
+      "Saving to: ‘data/XC9500_CPLD_Family.pdf’\n",
+      "\n",
+      "data/XC9500_CPLD_Fa 100%[===================>] 197.17K  --.-KB/s    in 0.03s   \n",
+      "\n",
+      "2025-02-06 20:24:19 (7.67 MB/s) - ‘data/XC9500_CPLD_Family.pdf’ saved [201899/201899]\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "!wget \"https://media.digikey.com/pdf/Data%20Sheets/AMD/XC9500_CPLD_Family.pdf\" -O data/XC9500_CPLD_Family.pdf"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4e29a9d7-5bd9-4fb8-8ec1-4c128a748662",
+   "metadata": {},
+   "source": [
+    "## Initialize LlamaParse\n",
+    "\n",
+    "Initialize LlamaParse in multimodal mode, and specify the vendor as `gemini-2.0-flash-001`.\n",
+    "\n",
+    "**NOTE**: Current pricing is 2 credits for a 1 page ($0.006 USD / page). This includes core model, infra, and algorithm costs to fully process the page. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dc921729-3446-42ca-8e1b-a6fd26195ed9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from llama_index.core.schema import TextNode\n",
+    "from typing import List\n",
+    "import json\n",
+    "\n",
+    "\n",
+    "def get_text_nodes(json_list: List[dict]):\n",
+    "    text_nodes = []\n",
+    "    for idx, page in enumerate(json_list):\n",
+    "        text_node = TextNode(text=page[\"md\"], metadata={\"page\": page[\"page\"]})\n",
+    "        text_nodes.append(text_node)\n",
+    "    return text_nodes\n",
+    "\n",
+    "\n",
+    "def save_jsonl(data_list, filename):\n",
+    "    \"\"\"Save a list of dictionaries as JSON Lines.\"\"\"\n",
+    "    with open(filename, \"w\") as file:\n",
+    "        for item in data_list:\n",
+    "            json.dump(item, file)\n",
+    "            file.write(\"\\n\")\n",
+    "\n",
+    "\n",
+    "def load_jsonl(filename):\n",
+    "    \"\"\"Load a list of dictionaries from JSON Lines.\"\"\"\n",
+    "    data_list = []\n",
+    "    with open(filename, \"r\") as file:\n",
+    "        for line in file:\n",
+    "            data_list.append(json.loads(line))\n",
+    "    return data_list"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f2e9d9cf-8189-4fcb-b34f-cde6cc0b59c8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Started parsing the file under job_id 51538aa0-13e6-4429-a458-a492ba7eec04\n"
+     ]
+    }
+   ],
+   "source": [
+    "from llama_parse import LlamaParse\n",
+    "\n",
+    "parsing_instruction = \"\"\"\n",
+    "You are given a technical datasheet of an electronic component.\n",
+    "For any graphs, try to create a 2D table of relevant values, along with a description of the graph.\n",
+    "For any schematic diagrams, MAKE SURE to describe a list of all components and their connections to each other.\n",
+    "Make sure that you always parse out the text with the correct reading order.\n",
+    "\"\"\"\n",
+    "\n",
+    "parser = LlamaParse(\n",
+    "    result_type=\"markdown\",\n",
+    "    use_vendor_multimodal_model=True,\n",
+    "    vendor_multimodal_model_name=\"gemini-2.0-flash-001\",\n",
+    "    invalidate_cache=True,\n",
+    "    parsing_instruction=parsing_instruction,\n",
+    ")\n",
+    "json_objs = parser.get_json_result(\"./data/XC9500_CPLD_Family.pdf\")\n",
+    "json_list = json_objs[0][\"pages\"]\n",
+    "docs = get_text_nodes(json_list)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "96a81df0-1026-4e30-a930-f677dc31e344",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Optional: Save\n",
+    "save_jsonl([d.dict() for d in docs], \"docs_gemini_2.0_flash.jsonl\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ee2e6920-8893-4b39-ae12-94d13c651406",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Optional: Load\n",
+    "from llama_index.core import Document\n",
+    "\n",
+    "docs_dicts = load_jsonl(\"docs_gemini_2.0_flash.jsonl\")\n",
+    "docs = [Document.parse_obj(d) for d in docs_dicts]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4f3c51b0-7878-48d7-9bc3-02b516500128",
+   "metadata": {},
+   "source": [
+    "### Setup GPT-4o baseline\n",
+    "\n",
+    "For comparison, we will also parse the document using GPT-4o ($0.03 per page)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6fc3f258-50ae-4988-b904-c105463a498f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Started parsing the file under job_id 23c6627c-2e3d-46c9-88a0-7945d7e65d96\n"
+     ]
+    }
+   ],
+   "source": [
+    "from llama_parse import LlamaParse\n",
+    "\n",
+    "parser_gpt4o = LlamaParse(\n",
+    "    result_type=\"markdown\",\n",
+    "    use_vendor_multimodal_model=True,\n",
+    "    vendor_multimodal_model=\"openai-gpt4o\",\n",
+    "    invalidate_cache=True,\n",
+    "    parsing_instruction=parsing_instruction,\n",
+    ")\n",
+    "json_objs_gpt4o = parser_gpt4o.get_json_result(\"./data/XC9500_CPLD_Family.pdf\")\n",
+    "json_list_gpt4o = json_objs_gpt4o[0][\"pages\"]\n",
+    "docs_gpt4o = get_text_nodes(json_list_gpt4o)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6a47f04e-12e1-4c80-a71d-ef7721f96401",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Optional: Save\n",
+    "save_jsonl([d.dict() for d in docs_gpt4o], \"docs_gpt4o.jsonl\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c38b5ca3-fa87-434b-b477-bf6a4962eb3d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Optional: Load\n",
+    "from llama_index.core import Document\n",
+    "\n",
+    "docs_gpt4o_dicts = load_jsonl(\"docs_gpt4o.jsonl\")\n",
+    "docs_gpt4o = [Document.parse_obj(d) for d in docs_gpt4o_dicts]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "44c20f7a-2901-4dd0-b635-a4b33c5664c1",
+   "metadata": {},
+   "source": [
+    "## View Results\n",
+    "\n",
+    "Let's visualize the results between GPT-4o and Gemini Flash 2.0 along with the original document page."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bf314141-9f6d-4453-beb9-0106cdf196bf",
+   "metadata": {},
+   "source": [
+    "Check out an example page 2 below."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c70d420d-1778-4b0d-81e2-db09276e90cf",
+   "metadata": {},
+   "source": [
+    "![xc9500_img](XC9500_CPLD_Family_p3.png)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0950ecad-248c-4c3c-98b9-ab1a9dabd5b4",
+   "metadata": {},
+   "source": [
+    "We see that the parsed text is fairly similar between Gemini 2.0 Flash and GPT-4o. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "778698aa-da7e-4081-b3b5-0372f228536f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "page: 3\n",
+      "\n",
+      "The image shows the architecture of the XC9500 In-System Programmable CPLD Family, which is marked as obsolete. Here's a breakdown of the components and their connections:\n",
+      "\n",
+      "### Components and Connections:\n",
+      "\n",
+      "1. **JTAG Port:**\n",
+      "   - Connects to the JTAG Controller.\n",
+      "\n",
+      "2. **JTAG Controller:**\n",
+      "   - Interfaces with the In-System Programming Controller.\n",
+      "   - Connects to the I/O Blocks.\n",
+      "\n",
+      "3. **In-System Programming Controller:**\n",
+      "   - Interfaces with the JTAG Controller and the Fast CONNECT Switch Matrix.\n",
+      "\n",
+      "4. **I/O Blocks:**\n",
+      "   - Multiple I/O lines connect to the Fast CONNECT Switch Matrix.\n",
+      "   - Includes special I/O lines for GCK, GSR, and GTS.\n",
+      "\n",
+      "5. **Fast CONNECT Switch Matrix:**\n",
+      "   - Connects to the I/O Blocks and Function Blocks.\n",
+      "   - Provides 36 inputs and 18 outputs to each Function Block.\n",
+      "\n",
+      "6. **Function Blocks (FB):**\n",
+      "   - Each block contains 18 macrocells.\n",
+      "   - Outputs from the Function Blocks drive the I/O Blocks directly.\n",
+      "   - Multiple Function Blocks (1 to N) are shown, each with 18 macrocells.\n",
+      "\n",
+      "### Function Block Details:\n",
+      "\n",
+      "- Each Function Block consists of 18 independent macrocells.\n",
+      "- Capable of implementing combinatorial or registered functions.\n",
+      "- Receives global clock, output enable, and set/reset signals.\n",
+      "- Generates 18 outputs for the Fast CONNECT switch matrix.\n",
+      "- Logic is implemented using a sum-of-products representation.\n",
+      "- 36 inputs provide 72 true and complement signals to form 90 product terms.\n",
+      "- Product terms can be allocated to each macrocell by the product term allocator.\n",
+      "- Supports local feedback paths for fast counters and state machines.\n",
+      "\n",
+      "This architecture is designed for flexibility in implementing complex logic functions within a programmable logic device.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# using Gemini 2.0 Flash\n",
+    "print(docs[2].get_content(metadata_mode=\"all\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1511a30f-3efc-4142-9668-7dc056a24d0c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "page: 3\n",
+      "\n",
+      "The diagram illustrates the architecture of the XC9500 In-System Programmable CPLD Family. Here's a breakdown of the components and their connections:\n",
+      "\n",
+      "1. **JTAG Port**: \n",
+      "   - Connects to the JTAG Controller.\n",
+      "\n",
+      "2. **JTAG Controller**: \n",
+      "   - Interfaces with the In-System Programming Controller.\n",
+      "\n",
+      "3. **In-System Programming Controller**: \n",
+      "   - Manages programming of the device.\n",
+      "\n",
+      "4. **I/O Blocks**: \n",
+      "   - Connect to external I/O pins.\n",
+      "   - Interface with the Fast CONNECT Switch Matrix.\n",
+      "\n",
+      "5. **Fast CONNECT Switch Matrix**: \n",
+      "   - Connects I/O Blocks to Function Blocks.\n",
+      "   - Provides 36 inputs and 18 outputs to each Function Block.\n",
+      "\n",
+      "6. **Function Blocks (FB)**: \n",
+      "   - Each block contains 18 macrocells.\n",
+      "   - Capable of implementing combinatorial or registered functions.\n",
+      "   - Receives global clock, output enable, and set/reset signals.\n",
+      "   - Outputs drive the Fast CONNECT Switch Matrix.\n",
+      "   - Supports local feedback paths for fast counters and state machines.\n",
+      "\n",
+      "7. **I/O/GCK, I/O/GSR, I/O/GTS**: \n",
+      "   - Special I/O pins for global clock, set/reset, and output enable signals.\n",
+      "\n",
+      "The architecture is designed for flexibility and high-speed operation, with each Function Block capable of handling complex logic functions.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# using GPT-4o\n",
+    "print(docs_gpt4o[2].get_content(metadata_mode=\"all\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "705f7729-fa0f-4ca0-8562-c42afeaa8532",
+   "metadata": {},
+   "source": [
+    "## Setup RAG Pipeline\n",
+    "\n",
+    "Let's setup a RAG pipeline over this data.\n",
+    "\n",
+    "(we also use gpt4o-mini for the actual text synthesis step)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5a53ee5d-cc63-421b-8896-588c83edfcf0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from llama_index.core import Settings\n",
+    "from llama_index.llms.openai import OpenAI\n",
+    "from llama_index.embeddings.openai import OpenAIEmbedding\n",
+    "\n",
+    "Settings.llm = OpenAI(model=\"o3-mini\")\n",
+    "Settings.embed_model = OpenAIEmbedding(model=\"text-embedding-3-large\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "60972d7a-7948-4ad7-89df-57004acee917",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# from llama_index.core import SummaryIndex\n",
+    "from llama_index.core import VectorStoreIndex\n",
+    "from llama_index.llms.openai import OpenAI\n",
+    "\n",
+    "index = VectorStoreIndex(docs)\n",
+    "query_engine = index.as_query_engine(similarity_top_k=5)\n",
+    "\n",
+    "index_gpt4o = VectorStoreIndex(docs_gpt4o)\n",
+    "query_engine_gpt4o = index_gpt4o.as_query_engine(similarity_top_k=5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e7df7bcb-1df4-4a01-88fc-2d596b1cc74d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "query = \"Give me the full output slew-Rate curve for (a) Rising and (b) Falling Outputs\"\n",
+    "\n",
+    "response = query_engine.query(query)\n",
+    "response_gpt4o = query_engine_gpt4o.query(query)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b7070a31-3bb8-4134-8338-20bc2fd6f3d6",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The full output slew-rate curve for (a) Rising and (b) Falling Outputs is represented in a graph where the output voltage starts at 1.5V and reaches the desired output level over a time period defined as T<sub>SLEW</sub>. The curve illustrates the gradual increase in voltage for rising outputs and the gradual decrease for falling outputs, effectively showing how the output edge rates can be controlled to reduce system noise.\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(response)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7bee8167-f021-4c87-8d28-9f40a4f7b69d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "# XC9500 In-System Programmable CPLD Family\n",
+      "\n",
+      "Each output has independent slew rate control. Output edge rates may be slowed down to reduce system noise (with an additional time delay of T<sub>SLEW</sub>) through programming. See Figure 11.\n",
+      "\n",
+      "Each IOB provides user programmable ground pin capability. This allows device I/O pins to be configured as additional ground pins. By tying strategically located programmable ground pins to the external ground connection, system noise generated from large numbers of simultaneous switching outputs may be reduced.\n",
+      "\n",
+      "A control pull-up resistor (typically 10K ohms) is attached to each device I/O pin to prevent them from floating when the device is not in normal user operation. This resistor is active during device programming mode and system power-up. It is also activated for an erased device. The resistor is deactivated during normal operation.\n",
+      "\n",
+      "The output driver is capable of supplying 24 mA output drive. All output drivers in the device may be configured for either 5V TTL levels or 3.3V levels by connecting the device output voltage supply (V<sub>CCIO</sub>) to a 5V or 3.3V voltage supply. Figure 12 shows how the XC9500 device can be used in 5V only and mixed 3.3V/5V systems.\n",
+      "\n",
+      "## Pin-Locking Capability\n",
+      "\n",
+      "The capability to lock the user defined pin assignments during design changes depends on the ability of the architecture to adapt to unexpected changes. The XC9500 devices have architectural features that enhance the ability to accept design changes while maintaining the same pinout.\n",
+      "\n",
+      "The XC9500 architecture provides maximum routing within the Fast CONNECT switch matrix, and incorporates a flexible Function Block that allows block-wide allocation of available product terms. This provides a high level of confidence of maintaining both input and output pin assignments for unexpected design changes.\n",
+      "\n",
+      "For extensive design changes requiring higher logic capacity than is available in the initially chosen device, the new design may be able to fit into a larger pin-compatible device using the same pin assignments. The same board may be used with a higher density device without the expense of board rework.\n",
+      "\n",
+      "!Output slew-Rate for (a) Rising and (b) Falling Outputs\n",
+      "\n",
+      "**Figure 11:** Output slew-Rate for (a) Rising and (b) Falling Outputs\n",
+      "\n",
+      "| Output Voltage | Time |\n",
+      "|----------------|------|\n",
+      "| 1.5V           | 0    |\n",
+      "| T<sub>SLEW</sub> |    |\n",
+      "\n",
+      "**Figure 12:** XC9500 Devices in (a) 5V Systems and (b) Mixed 5V/3.3V Systems\n",
+      "\n",
+      "| 5V CMOS or 5V TTL | 3.3V |\n",
+      "|-------------------|------|\n",
+      "| 5V                | 0V   |\n",
+      "| 3.6V              | 0V   |\n",
+      "| 3.3V              | 0V   |\n",
+      "\n",
+      "- **(a) 5V System:**\n",
+      "  - V<sub>CCINT</sub> V<sub>CCIO</sub>\n",
+      "  - XC9500 CPLD\n",
+      "  - IN OUT\n",
+      "  - GND\n",
+      "\n",
+      "- **(b) Mixed 5V/3.3V System:**\n",
+      "  - V<sub>CCINT</sub> V<sub>CCIO</sub>\n",
+      "  - XC9500 CPLD\n",
+      "  - IN OUT\n",
+      "  - GND\n",
+      "\n",
+      "www.xilinx.com\n",
+      "\n",
+      "DS063 (v6.0) May 17, 2013  \n",
+      "Product Specification\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(response.source_nodes[0].get_content())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5f9fef7f-510b-46a5-8716-f5616f542035",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The output slew-rate curve for (a) Rising and (b) Falling Outputs is represented in a timing diagram where the output voltage transitions from a low state to a high state and vice versa. \n",
+      "\n",
+      "For the rising output, the curve starts at 1.5V and transitions to the desired output voltage level over a time period defined as T<sub>SLEW</sub>. \n",
+      "\n",
+      "For the falling output, the curve similarly begins at the high output voltage and decreases to a low state, also taking the time defined as T<sub>SLEW</sub> to complete the transition.\n",
+      "\n",
+      "The specific values and graphical representation would typically be illustrated in a figure, but the key takeaway is that the output slew rate can be controlled to manage system noise by programming the desired T<sub>SLEW</sub> time.\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(response_gpt4o)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d40f9dd4-2dd4-4fa5-b636-1f901dc1601b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "# XC9500 In-System Programmable CPLD Family\n",
+      "\n",
+      "Each output has independent slew rate control. Output edge rates may be slowed down to reduce system noise (with an additional time delay of T<sub>SLEW</sub>) through programming. See Figure 11.\n",
+      "\n",
+      "Each IOB provides user programmable ground pin capability. This allows device I/O pins to be configured as additional ground pins. By tying strategically located programmable ground pins to the external ground connection, system noise generated from large numbers of simultaneous switching outputs may be reduced.\n",
+      "\n",
+      "A control pull-up resistor (typically 10K ohms) is attached to each device I/O pin to prevent them from floating when the device is not in normal user operation. This resistor is active during device programming mode and system power-up. It is also activated for an erased device. The resistor is deactivated during normal operation.\n",
+      "\n",
+      "The output driver is capable of supplying 24 mA output drive. All output drivers in the device may be configured for either 5V TTL levels or 3.3V levels by connecting the device output voltage supply (V<sub>CCIO</sub>) to a 5V or 3.3V voltage supply. Figure 12 shows how the XC9500 device can be used in 5V only and mixed 3.3V/5V systems.\n",
+      "\n",
+      "## Pin-Locking Capability\n",
+      "\n",
+      "The capability to lock the user defined pin assignments during design changes depends on the ability of the architecture to adapt to unexpected changes. The XC9500 devices have architectural features that enhance the ability to accept design changes while maintaining the same pinout.\n",
+      "\n",
+      "The XC9500 architecture provides maximum routing within the Fast CONNECT switch matrix, and incorporates a flexible Function Block that allows block-wide allocation of available product terms. This provides a high level of confidence of maintaining both input and output pin assignments for unexpected design changes.\n",
+      "\n",
+      "For extensive design changes requiring higher logic capacity than is available in the initially chosen device, the new design may be able to fit into a larger pin-compatible device using the same pin assignments. The same board may be used with a higher density device without the expense of board rework.\n",
+      "\n",
+      "!Output slew-Rate for (a) Rising and (b) Falling Outputs\n",
+      "\n",
+      "**Figure 11:** Output slew-Rate for (a) Rising and (b) Falling Outputs\n",
+      "\n",
+      "| Output Voltage | Time |\n",
+      "|----------------|------|\n",
+      "| 1.5V           | 0    |\n",
+      "| T<sub>SLEW</sub> |    |\n",
+      "\n",
+      "**Figure 12:** XC9500 Devices in (a) 5V Systems and (b) Mixed 5V/3.3V Systems\n",
+      "\n",
+      "| 5V CMOS or 5V TTL | 3.3V |\n",
+      "|-------------------|------|\n",
+      "| 5V                | 0V   |\n",
+      "| 3.6V              | 0V   |\n",
+      "| 3.3V              | 0V   |\n",
+      "\n",
+      "- **XC9500 CPLD**  \n",
+      "  - **IN**  \n",
+      "  - **OUT**  \n",
+      "  - **GND**  \n",
+      "\n",
+      "www.xilinx.com  \n",
+      "DS063 (v6.0) May 17, 2013  \n",
+      "Product Specification\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(response_gpt4o.source_nodes[0].get_content())"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "llama_parse",
+   "language": "python",
+   "name": "llama_parse"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

examples/parse/multimodal/gpt4o_mini.ipynb

@@ -7,7 +7,7 @@
    "source": [
     "# Multimodal Parsing using GPT4o-mini\n",
     "\n",
-    "<a href=\"https://colab.research.google.com/github/run-llama/llama_parse/blob/main/examples/multimodal/gpt4o_mini.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
+    "<a href=\"https://colab.research.google.com/github/run-llama/llama_cloud_services/blob/main/examples/parse/multimodal/gpt4o_mini.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
     "\n",
     "This cookbook shows you how to use LlamaParse to parse any document with the multimodal capabilities of GPT4o-mini.\n",
     "\n",
@@ -118,7 +118,7 @@
     }
    ],
    "source": [
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "\n",
     "parser = LlamaParse(\n",
     "    result_type=\"markdown\",\n",
@@ -181,7 +181,7 @@
     }
    ],
    "source": [
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "\n",
     "parser_gpt4o = LlamaParse(\n",
     "    result_type=\"markdown\",\n",

examples/parse/multimodal/insurance_rag.ipynb

@@ -6,7 +6,7 @@
    "source": [
     "# Building a Multimodal RAG Pipeline over an Auto Insurance Claim\n",
     "\n",
-    "<a href=\"https://colab.research.google.com/github/run-llama/llama_parse/blob/main/examples/multimodal/insurance_rag.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+    "<a href=\"https://colab.research.google.com/github/run-llama/llama_cloud_services/blob/main/examples/parse/multimodal/insurance_rag.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
    ]
   },
   {
@@ -99,7 +99,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "\n",
     "parser = LlamaParse(\n",
     "    result_type=\"markdown\",\n",

examples/parse/multimodal/legal_rag.ipynb

@@ -6,7 +6,7 @@
    "source": [
     "# Building a RAG Pipeline over Legal Documents\n",
     "\n",
-    "<a href=\"https://colab.research.google.com/github/run-llama/llama_parse/blob/main/examples/multimodal/legal_rag.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
+    "<a href=\"https://colab.research.google.com/github/run-llama/llama_cloud_services/blob/main/examples/parse/multimodal/legal_rag.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
     "\n",
     "This example shows how LlamaParse and LlamaIndex can be used to parse various types of legal documents, which may contain complex tabular data. The advantage of this is being able to quickly retrieve a specific answer to a legal question with comprehensive context — knowledge of precedents, statutes, and cases presented in the given documents. A user can quickly find the answer to or find out more details about a specific legal question without having to read through the often long documents by using LLMs.\n",
     "\n",
@@ -102,7 +102,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "\n",
     "parser = LlamaParse(\n",
     "    result_type=\"markdown\",\n",

examples/parse/multimodal/multimodal_contextual_retrieval_rag.ipynb

@@ -7,7 +7,7 @@
    "source": [
     "# Contextual Retrieval for Multimodal RAG\n",
     "\n",
-    "<a href=\"https://colab.research.google.com/github/run-llama/llama_parse/blob/main/examples/multimodal/multimodal_contextual_retrieval_rag.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
+    "<a href=\"https://colab.research.google.com/github/run-llama/llama_cloud_services/blob/main/examples/parse/multimodal/multimodal_contextual_retrieval_rag.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
     "\n",
     "In this cookbook we show you how to build a multimodal RAG pipeline with **contextual retrieval**.\n",
     "\n",
@@ -169,7 +169,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "\n",
     "\n",
     "parser = LlamaParse(\n",

examples/parse/multimodal/multimodal_rag_slide_deck.ipynb

@@ -7,7 +7,7 @@
    "source": [
     "# Building a Natively Multimodal RAG Pipeline (over a Slide Deck)\n",
     "\n",
-    "<a href=\"https://colab.research.google.com/github/run-llama/llama_parse/blob/main/examples/multimodal/multimodal_rag_slide_deck.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
+    "<a href=\"https://colab.research.google.com/github/run-llama/llama_cloud_services/blob/main/examples/parse/multimodal/multimodal_rag_slide_deck.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
     "\n",
     "In this cookbook we show you how to build a multimodal RAG pipeline over a slide deck, with text, tables, images, diagrams, and complex layouts.\n",
     "\n",
@@ -153,7 +153,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "\n",
     "\n",
     "parser_text = LlamaParse(result_type=\"text\")\n",

examples/parse/multimodal/multimodal_report_generation.ipynb

@@ -7,7 +7,7 @@
    "source": [
     "# Multimodal Report Generation (from a Slide Deck)\n",
     "\n",
-    "<a href=\"https://colab.research.google.com/github/run-llama/llama_parse/blob/main/examples/multimodal/multimodal_report_generation.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
+    "<a href=\"https://colab.research.google.com/github/run-llama/llama_cloud_services/blob/main/examples/parse/multimodal/multimodal_report_generation.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
     "\n",
     "In this cookbook we show you how to build a multimodal report generator. The pipeline parses a slide deck and stores both text and image chunks. It generates a detailed response that contains interleaving text and images.\n",
     "\n",
@@ -143,7 +143,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "\n",
     "parser = LlamaParse(\n",
     "    result_type=\"markdown\",\n",

examples/parse/multimodal/multimodal_report_generation_agent.ipynb

@@ -7,7 +7,7 @@
    "source": [
     "# Multimodal Report Generation Agent \n",
     "\n",
-    "<a href=\"https://colab.research.google.com/github/run-llama/llama_parse/blob/main/examples/multimodal/multimodal_report_generation_agent.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
+    "<a href=\"https://colab.research.google.com/github/run-llama/llama_cloud_services/blob/main/examples/parse/multimodal/multimodal_report_generation_agent.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
     "\n",
     "In this cookbook we show you how to build a multimodal report generation agent from a bank of research reports. We use the a set of ICLR papers (which were also used as the dataset in our [DeepLearning.ai course](https://www.deeplearning.ai/short-courses/building-agentic-rag-with-llamaindex/?utm_campaign=llamaindexC2-launch&utm_medium=headband&utm_source=dlai-homepage).\n",
     "\n",
@@ -172,7 +172,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "\n",
     "parser = LlamaParse(\n",
     "    result_type=\"markdown\",\n",

examples/parse/multimodal/product_manual_rag.ipynb

@@ -6,7 +6,7 @@
    "source": [
     "# Building a RAG Pipeline over IKEA Product Instruction Manuals\n",
     "\n",
-    "<a href=\"https://colab.research.google.com/github/run-llama/llama_parse/blob/main/examples/multimodal/product_manual_rag.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+    "<a href=\"https://colab.research.google.com/github/run-llama/llama_cloud_services/blob/main/examples/parse/multimodal/product_manual_rag.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
    ]
   },
   {
@@ -104,7 +104,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "\n",
     "parser = LlamaParse(\n",
     "    result_type=\"markdown\",\n",

examples/parse/other_files/demo_ppt_basic.ipynb

@@ -25,7 +25,7 @@
     "\n",
     "nest_asyncio.apply()\n",
     "\n",
-    "from llama_parse import LlamaParse"
+    "from llama_cloud_services import LlamaParse"
    ]
   },
   {

examples/parse/other_files/demo_ppt_financial.ipynb

@@ -27,7 +27,7 @@
    "outputs": [],
    "source": [
     "%pip install llama-index\n",
-    "%pip install llama-parse\n",
+    "%pip install llama-cloud-services\n",
     "%pip install torch transformers python-pptx Pillow"
    ]
   },
@@ -85,7 +85,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from llama_parse import LlamaParse"
+    "from llama_cloud_services import LlamaParse"
    ]
   },
   {

examples/parse/parsing_instructions/parsing_instructions.ipynb

@@ -0,0 +1,602 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a href=\"https://colab.research.google.com/github/run-llama/llama_cloud_services/blob/main/examples/parse/parsing_instructions.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
+    "\n",
+    "# Parsing documents with Instructions\n",
+    "\n",
+    "Parsing instructions allow you to guide our parsing model in the same way you would instruct an LLM.\n",
+    "\n",
+    "These instructions can be useful for improving the parser's performance on complex document layouts, extracting data in a specific format, or transforming the document in other ways.\n",
+    "\n",
+    "### Why This Matters:\n",
+    "Traditional document parsing can be rigid and error-prone, often missing crucial context and nuances in complex layouts. Our instruction-based parsing allows you to:\n",
+    "\n",
+    "1. Extract specific information with pinpoint accuracy\n",
+    "2. Handle complex document layouts with ease\n",
+    "3. Transform unstructured data into structured formats effortlessly\n",
+    "4. Save hours of manual data entry and verification\n",
+    "5. Reduce errors in document processing workflows\n",
+    "\n",
+    "In this demonstration, we showcase how parsing instructions can be used to extract specific information from unstructured documents. Below are the documents we use for testing:\n",
+    "\n",
+    "1. McDonald's Receipt - Extracting the price of each order and the final amount to be paid.\n",
+    "\n",
+    "2. Expense Report Document - Extracting employee name, employee ID, position, department, date ranges, individual expense items with dates, categories, and amounts.\n",
+    "\n",
+    "3. Purchase Order Document - Identifying the PO number, vendor details, shipping terms, and an itemized list of products with quantities and unit prices.\n",
+    "\n",
+    "Let's jump into these real-world examples and see how parsing instructions can help us extract specific information."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Installation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install llama-cloud-services"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Setup API Key"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import nest_asyncio\n",
+    "\n",
+    "nest_asyncio.apply()\n",
+    "\n",
+    "import os\n",
+    "\n",
+    "os.environ[\"LLAMA_CLOUD_API_KEY\"] = \"llx-...\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### McDonald's Receipt\n",
+    "\n",
+    "Here we extract the price of each order and the final amount to be paid."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<img src=\"mcdonalds_receipt.png\" alt=\"Alt Text\" width=\"500\">"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Started parsing the file under job_id 66643b81-e2f4-408b-890b-8e116472210b\n"
+     ]
+    }
+   ],
+   "source": [
+    "from llama_cloud_services import LlamaParse\n",
+    "\n",
+    "vanilaParsing = LlamaParse(result_type=\"markdown\").load_data(\"./mcdonalds_receipt.png\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "# Rate us HIGHLY SATISFIED\n",
+      "\n",
+      "Purchase any sandwich and receive a FREE ITEM\n",
+      "\n",
+      "Go to WWW.mcdvoice.com within 7 days of purchase of equal or lesser value and tell us about your visit.\n",
+      "\n",
+      "Validation Code: 31278-01121-21018-20481-00081-0\n",
+      "\n",
+      "Valid at participating US McDonald's\n",
+      "\n",
+      "Expires 30 days after receipt date\n",
+      "\n",
+      "# McDonald's Restaurant #312782378\n",
+      "\n",
+      "PINE RD NW\n",
+      "\n",
+      "RICE MN 56367-9740\n",
+      "\n",
+      "TEL# 320 393 4600\n",
+      "\n",
+      "KS# 12/08/2022 08:48 PM\n",
+      "\n",
+      "# Order\n",
+      "\n",
+      "|Happy Meal 6 Pc|$4.89|\n",
+      "|---|---|\n",
+      "|Creamy Ranch Cup| |\n",
+      "|Extra Kids Fry| |\n",
+      "|Wreck It Ralph 2 Snack| |\n",
+      "|Oreo McFlurry|$2.69|\n",
+      "\n",
+      "# Summary\n",
+      "\n",
+      "|Subtotal|$7.58|\n",
+      "|---|---|\n",
+      "|Tax|$0.52|\n",
+      "|Take-Out Total|$8.10|\n",
+      "|Cash Tendered|$10.00|\n",
+      "|Change|$1.90|\n",
+      "\n",
+      "### Not ACCEPTING APPLICATIONS *++ McDonald's Restaurant Rice\n",
+      "\n",
+      "Text to #36453 apply 31278\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(vanilaParsing[0].text)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Started parsing the file under job_id 1a04fdbb-5415-4a36-a1bd-26bfb5d618fa\n"
+     ]
+    }
+   ],
+   "source": [
+    "parsingInstruction = \"\"\"The provided document is a McDonald's receipt.\n",
+    " Provide the price of each order and final amount to be paid.\"\"\"\n",
+    "withInstructionParsing = LlamaParse(\n",
+    "    result_type=\"markdown\", parsing_instruction=parsingInstruction\n",
+    ").load_data(\"./mcdonalds_receipt.png\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Here are the prices for each order from the McDonald's receipt:\n",
+      "\n",
+      "1. Happy Meal 6 Pc: $4.89\n",
+      "2. Snack Oreo McFlurry: $2.69\n",
+      "\n",
+      "**Subtotal:** $7.58\n",
+      "**Tax:** $0.52\n",
+      "**Total Amount to be Paid:** $8.10\n",
+      "\n",
+      "The cash tendered was $10.00, and the change given was $1.90.\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(withInstructionParsing[0].text)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Expense Report Document\n",
+    "\n",
+    "Here we extract employee name, employee ID, position, department, date ranges, individual expense items with dates, categories, and amounts."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<img src=\"expense_report_document.png\" alt=\"Alt Text\" width=\"500\">"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Started parsing the file under job_id b6bcc6e1-7d30-4522-9abd-ace196781a70\n"
+     ]
+    }
+   ],
+   "source": [
+    "vanilaParsing = LlamaParse(result_type=\"markdown\").load_data(\n",
+    "    \"./expense_report_document.pdf\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "# QUANTUM DYNAMICS CORPORATION\n",
+      "\n",
+      "# EMPLOYEE EXPENSE REPORT\n",
+      "\n",
+      "# FISCAL YEAR 2024\n",
+      "\n",
+      "# EMPLOYEE INFORMATION:\n",
+      "\n",
+      "Name: Dr. Alexandra Chen-Martinez, PhD\n",
+      "\n",
+      "Employee ID: QD-2022-1457\n",
+      "\n",
+      "Department: Advanced Research & Development\n",
+      "\n",
+      "Cost Center: CC-ARD-NA-003\n",
+      "\n",
+      "Project Codes: QD-QUANTUM-2024-01, QD-AI-2024-03\n",
+      "\n",
+      "Position: Principal Research Scientist\n",
+      "\n",
+      "Reporting Manager: Dr. James Thompson\n",
+      "\n",
+      "# TRIP/EXPENSE PERIOD:\n",
+      "\n",
+      "Start Date: November 15, 2024\n",
+      "\n",
+      "End Date: December 10, 2024\n",
+      "\n",
+      "Purpose: International Conference Attendance & Client Meetings\n",
+      "\n",
+      "Locations: Tokyo, Japan → Singapore → Sydney, Australia\n",
+      "\n",
+      "# CURRENCY CONVERSION RATES APPLIED:\n",
+      "\n",
+      "JPY (¥) → USD: 0.0068 (as of 11/15/2024)\n",
+      "\n",
+      "SGD (S$) → USD: 0.74 (as of 11/28/2024)\n",
+      "\n",
+      "AUD (A$) → USD: 0.65 (as of 12/03/2024)\n",
+      "\n",
+      "# ITEMIZED EXPENSES:\n",
+      "\n",
+      "|Date|Category|Description|Original|Currency|USD|\n",
+      "|---|---|---|---|---|---|\n",
+      "|11/15/2024|Transportation|JFK → NRT Business Class|4,250.00|USD|4,250.00|\n",
+      "|Booking Ref: QF78956 - Corporate Rate Applied|Booking Ref: QF78956 - Corporate Rate Applied|Booking Ref: QF78956 - Corporate Rate Applied|Booking Ref: QF78956 - Corporate Rate Applied|Booking Ref: QF78956 - Corporate Rate Applied|Booking Ref: QF78956 - Corporate Rate Applied|\n",
+      "|Project Code: QD-QUANTUM-2024-01|Project Code: QD-QUANTUM-2024-01|Project Code: QD-QUANTUM-2024-01|Project Code: QD-QUANTUM-2024-01|Project Code: QD-QUANTUM-2024-01|Project Code: QD-QUANTUM-2024-01|\n",
+      "|11/16/2024|Accommodation|Hilton Tokyo - 5 nights|225,000|JPY|1,530.00|\n",
+      "|Confirmation: HTK-2024-78956|Confirmation: HTK-2024-78956|Confirmation: HTK-2024-78956|Confirmation: HTK-2024-78956|Confirmation: HTK-2024-78956|Confirmation: HTK-2024-78956|\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(vanilaParsing[0].text)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Started parsing the file under job_id 7b0d05bb-947b-4475-8d0f-f10386f7446e\n"
+     ]
+    }
+   ],
+   "source": [
+    "parsingInstruction = \"\"\"You are provided with an expense report. \n",
+    "Extract employee name, employee id, position, department, date ranges, individual expense items with dates, categories, and amounts.\"\"\"\n",
+    "\n",
+    "withInstructionParsing = LlamaParse(\n",
+    "    result_type=\"markdown\", parsing_instruction=parsingInstruction\n",
+    ").load_data(\"./expense_report_document.pdf\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "**Employee Information:**\n",
+      "- **Name:** Dr. Alexandra Chen-Martinez, PhD\n",
+      "- **Employee ID:** QD-2022-1457\n",
+      "- **Position:** Principal Research Scientist\n",
+      "- **Department:** Advanced Research & Development\n",
+      "\n",
+      "**Trip/Expense Period:**\n",
+      "- **Start Date:** November 15, 2024\n",
+      "- **End Date:** December 10, 2024\n",
+      "\n",
+      "**Expense Items:**\n",
+      "1. **Date:** 11/15/2024\n",
+      "- **Category:** Transportation\n",
+      "- **Description:** JFK → NRT Business Class\n",
+      "- **Original Amount:** $4,250.00\n",
+      "- **Currency:** USD\n",
+      "- **USD Amount:** $4,250.00\n",
+      "- **Booking Reference:** QF78956 - Corporate Rate Applied\n",
+      "- **Project Code:** QD-QUANTUM-2024-01\n",
+      "\n",
+      "2. **Date:** 11/16/2024\n",
+      "- **Category:** Accommodation\n",
+      "- **Description:** Hilton Tokyo - 5 nights\n",
+      "- **Original Amount:** ¥225,000\n",
+      "- **Currency:** JPY\n",
+      "- **USD Amount:** $1,530.00\n",
+      "- **Confirmation:** HTK-2024-78956\n",
+      "\n",
+      "**Locations:**\n",
+      "- Tokyo, Japan\n",
+      "- Singapore\n",
+      "- Sydney, Australia\n",
+      "\n",
+      "**Currency Conversion Rates Applied:**\n",
+      "- JPY (¥) → USD: 0.0068 (as of 11/15/2024)\n",
+      "- SGD (S$) → USD: 0.74 (as of 11/28/2024)\n",
+      "- AUD (A$) → USD: 0.65 (as of 12/03/2024)\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(withInstructionParsing[0].text)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Purchase Order Document \n",
+    "\n",
+    "Here we identify the PO number, vendor details, shipping terms, and an itemized list of products with quantities and unit prices."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<img src=\"purchase_order_document.png\" alt=\"Alt Text\" width=\"500\">"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Started parsing the file under job_id b8cb11c3-7dce-4e6a-94bb-1a4e50e45e55\n"
+     ]
+    }
+   ],
+   "source": [
+    "vanilaParsing = LlamaParse(result_type=\"markdown\").load_data(\n",
+    "    \"./purchase_order_document.pdf\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "# GLOBAL TECH SOLUTIONS, INC.\n",
+      "\n",
+      "# PURCHASE ORDER\n",
+      "\n",
+      "Document Reference: PO-2024-GT-9876/REV.2\n",
+      "\n",
+      "[Original: PO-2024-GT-9876]\n",
+      "\n",
+      "Amendment Date: 12/10/2024\n",
+      "\n",
+      "# VENDOR INFORMATION:\n",
+      "\n",
+      "Quantum Electronics Manufacturing\n",
+      "\n",
+      "DUNS: 78-456-7890\n",
+      "\n",
+      "Tax ID: EU8976543210\n",
+      "\n",
+      "Hoofdorp, Netherlands\n",
+      "\n",
+      "Vendor #: QEM-EU-2024-001\n",
+      "\n",
+      "# SHIP TO:\n",
+      "\n",
+      "Global Tech Solutions, Inc.\n",
+      "\n",
+      "Building 7A, Innovation Park\n",
+      "\n",
+      "2100 Technology Drive\n",
+      "\n",
+      "Austin, TX 78701\n",
+      "\n",
+      "USA\n",
+      "\n",
+      "Attn: Sarah Martinez, Receiving Manager\n",
+      "\n",
+      "Tel: +1 (512) 555-0123\n",
+      "\n",
+      "# PAYMENT TERMS:\n",
+      "\n",
+      "Net 45\n",
+      "\n",
+      "2% discount if paid within 15 days\n",
+      "\n",
+      "# SHIPPING TERMS:\n",
+      "\n",
+      "DDP (Delivered Duty Paid) - Incoterms 2020\n",
+      "\n",
+      "Insurance Required: Yes\n",
+      "\n",
+      "Preferred Carrier: DHL/FedEx\n",
+      "\n",
+      "Required Delivery Date: 01/15/2025\n",
+      "\n",
+      "# SPECIAL INSTRUCTIONS:\n",
+      "\n",
+      "1. All shipments must include Certificate of Conformance\n",
+      "2. ESD-sensitive items must be properly packaged\n",
+      "3. Temperature logging required for items marked with *\n",
+      "4. Partial shipments accepted with prior approval\n",
+      "5. Quote PO number on all correspondence\n",
+      "\n",
+      "# ITEM DETAILS:\n",
+      "\n",
+      "|Line|Part Number|Description|Qty|UOM|Unit Price|Total|\n",
+      "|---|---|---|---|---|---|---|\n",
+      "|1|QE-MCU-5590|Microcontroller Unit|500|EA|$12.50|$6,250.00|\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(vanilaParsing[0].text)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Started parsing the file under job_id d2731305-984d-4633-8a52-0493748cf10b\n"
+     ]
+    }
+   ],
+   "source": [
+    "parsingInstruction = \"\"\"You are provided with a purchase order. \n",
+    "Identify the PO number, vendor details, shipping terms, and itemized list of products with quantities and unit prices.\"\"\"\n",
+    "\n",
+    "withInstructionParsing = LlamaParse(\n",
+    "    result_type=\"markdown\", parsing_instruction=parsingInstruction\n",
+    ").load_data(\"./purchase_order_document.pdf\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Here are the details extracted from the purchase order:\n",
+      "\n",
+      "**PO Number:** PO-2024-GT-9876/REV.2\n",
+      "\n",
+      "**Vendor Details:**\n",
+      "- **Vendor Name:** Quantum Electronics Manufacturing\n",
+      "- **DUNS:** 78-456-7890\n",
+      "- **Tax ID:** EU8976543210\n",
+      "- **Address:** Hoofdorp, Netherlands\n",
+      "- **Vendor Number:** QEM-EU-2024-001\n",
+      "- **Contact Person:** Sarah Martinez, Receiving Manager\n",
+      "- **Phone:** +1 (512) 555-0123\n",
+      "\n",
+      "**Shipping Terms:**\n",
+      "- **Terms:** DDP (Delivered Duty Paid) - Incoterms 2020\n",
+      "- **Insurance Required:** Yes\n",
+      "- **Preferred Carrier:** DHL/FedEx\n",
+      "- **Required Delivery Date:** 01/15/2025\n",
+      "\n",
+      "**Itemized List of Products:**\n",
+      "1. **Part Number:** QE-MCU-5590\n",
+      "- **Description:** Microcontroller Unit\n",
+      "- **Quantity:** 500 EA\n",
+      "- **Unit Price:** $12.50\n",
+      "- **Total:** $6,250.00\n",
+      "\n",
+      "**Payment Terms:**\n",
+      "- Net 45\n",
+      "- 2% discount if paid within 15 days\n",
+      "\n",
+      "**Special Instructions:**\n",
+      "1. All shipments must include Certificate of Conformance\n",
+      "2. ESD-sensitive items must be properly packaged\n",
+      "3. Temperature logging required for items marked with *\n",
+      "4. Partial shipments accepted with prior approval\n",
+      "5. Quote PO number on all correspondence\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(withInstructionParsing[0].text)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "llamacloud",
+   "language": "python",
+   "name": "llamacloud"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

examples/parse/report_generation/rfp_response/generate_rfp.ipynb

@@ -7,7 +7,7 @@
    "source": [
     "# RFP Response Generation Workflow\n",
     "\n",
-    "<a href=\"https://colab.research.google.com/github/run-llama/llama_parse/blob/main/examples/report_generation/rfp_response/generate_rfp.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
+    "<a href=\"https://colab.research.google.com/github/run-llama/llama_cloud_services/blob/main/examples/parse/report_generation/rfp_response/generate_rfp.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
     "\n",
     "This notebook shows you how to build a workflow to generate a response to an RFP. \n",
     "\n",
@@ -20,7 +20,7 @@
     "\n",
     "We use LlamaParse to parse the context documents as well as the RFP document itself.\n",
     "\n",
-    "**NOTE**: If you want to skip the indexing complexity and use LlamaCloud instead, check out the [RFP Example using LlamaCloud](https://github.com/run-llama/llamacloud-demo/blob/main/examples/report_generation/rfp_response/generate_rfp.ipynb)."
+    "**NOTE**: If you want to skip the indexing complexity and use LlamaCloud instead, check out the [RFP Example using LlamaCloud](https://github.com/run-llama/llama_cloud_services-demo/blob/main/examples/report_generation/rfp_response/generate_rfp.ipynb)."
    ]
   },
   {
@@ -95,7 +95,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "\n",
     "# use our multimodal models for extractions\n",
     "parser = LlamaParse(\n",

examples/parse/test_tesla_impact_report/test_gpt4o.ipynb

@@ -8,7 +8,7 @@
     "# LlamaParse with GPT-4o\n",
     "\n",
     "\n",
-    "<a href=\"https://colab.research.google.com/github/run-llama/llama_parse/blob/main/examples/test_tesla_impact_report/test_gpt4o.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
+    "<a href=\"https://colab.research.google.com/github/run-llama/llama_cloud_services/blob/main/examples/parse/test_tesla_impact_report/test_gpt4o.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
     "\n",
     "GPT-4o is a [fully multimodal model by OpenAI](https://openai.com/index/hello-gpt-4o/) released in May 2024. It matches GPT-4 Turbo performance in text and code, and has significantly improved vision and audio capabilities.\n",
     "\n",
@@ -107,7 +107,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from llama_parse import LlamaParse\n",
+    "from llama_cloud_services import LlamaParse\n",
     "\n",
     "parser_gpt4o = LlamaParse(\n",
     "    result_type=\"markdown\",\n",

examples/report/basic_report.ipynb

@@ -0,0 +1,762 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Report Generation with LlamaReport\n",
+    "\n",
+    "In this notebook, we'll walk through the basic process of generating a report with LlamaReport, and highlight some of the key features of the library.\n",
+    "\n",
+    "TLDR:\n",
+    "1. Download source data to use as knowledge base for the report\n",
+    "2. Kick off report generation with a template\n",
+    "3. Get the plan and review/accept/reject suggestions\n",
+    "4. Get the final report\n",
+    "5. Review/accept/reject suggestions to edit the final report\n",
+    "6. Print the final report"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%pip install llama-cloud-services"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Download Source Data\n",
+    "\n",
+    "Here, we download the `Attention is All You Need` paper as a PDF.\n",
+    "\n",
+    "LlamaReport currently supports up to 5 files as input, and essentially any file type that can be parsed by LlamaParse.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!wget \"https://arxiv.org/pdf/1706.03762.pdf\" -O \"./attention.pdf\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Kick off Report Generation\n",
+    "\n",
+    "Here, we kick off report generation with a template.\n",
+    "\n",
+    "The template can either be a string or a file path, but here we'll use a string.\n",
+    "\n",
+    "In our experiments, anything works as a template, but some general guidelines:\n",
+    "\n",
+    "- Use markdown formatting + instructions in each section to guide the report generation\n",
+    "- If using an existing file as a template, provide extra instructions to guide the report generation\n",
+    "\n",
+    "**NOTE:** Since we are in a notebook, we will use async functions and `await` throughout. Synchronous methods that work without `await` are available by just removing the `a` from the method name and removing the `await` keyword."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from llama_cloud_services import LlamaReport\n",
+    "\n",
+    "llama_report = LlamaReport(\n",
+    "    api_key=\"llx-...\",\n",
+    ")\n",
+    "\n",
+    "report_client = await llama_report.acreate_report(\n",
+    "    name=\"my_cool_report_on_attention\",\n",
+    "    # can pass in file paths or bytes\n",
+    "    input_files=[\"./attention.pdf\"],\n",
+    "    template_text=\"\"\"\\\n",
+    "# [Some title]\\n\\n\n",
+    "## TLDR\\n\n",
+    "A quick summary of the paper.\\n\\n\n",
+    "## Details\\n\n",
+    "More details about the paper, possibly more than one section here.\\n\n",
+    "\"\"\",\n",
+    "    # optional additional instructions for the report generation\n",
+    "    # template_instructions=None,\n",
+    "    # optional file path to an existing template instead of template_text\n",
+    "    # template_file=None,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The returned `ReportClient` object is used to interact with the report generation process for this specific report."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Report(id=0a394b33-1a3e-463c-b5cb-7ff8ab827d0a, name=my_cool_report_on_attention)\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(report_client)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Get the plan\n",
+    "\n",
+    "The first phases of report generation involve ingesting the source data and generating a plan.\n",
+    "\n",
+    "The plan is a list of instructions for the report generation, and can be reviewed/accepted/rejected by the user.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plan = await report_client.await_for_plan(\n",
+    "    timeout=10000,\n",
+    "    poll_interval=10,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "# {title}\n",
+      "[ReportQuery(field='title', prompt='Generate a clear and concise title for this paper about the Transformer model and attention mechanisms', context='The paper discusses the Transformer architecture for sequence transduction using attention mechanisms, focusing on machine translation applications')]\n",
+      "==================\n",
+      "## TLDR\n",
+      "\n",
+      "{tldr_content}\n",
+      "[ReportQuery(field='tldr_content', prompt='Write a brief, clear summary of the key points about the Transformer model', context='Focus on the main innovations: attention mechanisms, efficiency improvements, and state-of-the-art results in machine translation')]\n",
+      "==================\n",
+      "## Details\n",
+      "\n",
+      "{details_content}\n",
+      "[ReportQuery(field='details_content', prompt='Provide detailed information about the Transformer model architecture and its applications', context='Include information about:\\n- The attention mechanism implementation\\n- Advantages over recurrent and convolutional models\\n- Performance in machine translation tasks\\n- Training efficiency improvements')]\n",
+      "==================\n"
+     ]
+    }
+   ],
+   "source": [
+    "for plan_block in plan.blocks:\n",
+    "    print(plan_block.block.template)\n",
+    "    print(plan_block.queries)\n",
+    "    print(\"==================\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "With the plan, we can either use it to kick off generation of the final report, or we can edit the plan and adjust it as needed.\n",
+    "\n",
+    "While we could manually edit the objects here and use `await report_client.aupdate_plan(action=\"edit\", updated_plan=plan)`, we can also use `LlamaReport` to agentically edit the plan."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "suggestions = await report_client.asuggest_edits(\n",
+    "    \"Can you split the details section into two sections?\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Justification for change: \n",
+      "I'll help you break down the details section into two distinct parts - one focusing on the architecture and another on the practical applications and performance. This will make the content more organized and easier to follow. The original block at index 2 will be replaced with these two new sections.\n",
+      "\n",
+      "Proposed changes:\n",
+      "\n",
+      "## Architecture Details\n",
+      "\n",
+      "{architecture_content}\n",
+      "\n",
+      "[ReportQuery(field='architecture_content', prompt='Describe the technical details of the Transformer model architecture', context='Focus on:\\n- Core components of the Transformer architecture\\n- Self-attention mechanism implementation\\n- Multi-head attention details\\n- Position encoding approach\\n- Feed-forward network structure')]\n",
+      "==================\n",
+      "\n",
+      "## Performance and Applications\n",
+      "\n",
+      "{applications_content}\n",
+      "\n",
+      "[ReportQuery(field='applications_content', prompt='Explain the practical applications and performance advantages of the Transformer model', context='Cover:\\n- Comparison with RNN and CNN models\\n- Machine translation results and benchmarks\\n- Training efficiency improvements\\n- Real-world applications and use cases\\n- Scalability benefits')]\n",
+      "==================\n"
+     ]
+    }
+   ],
+   "source": [
+    "for suggestion in suggestions:\n",
+    "    print(\"Justification for change:\", suggestion.justification)\n",
+    "    print(\"Proposed changes:\")\n",
+    "    for plan_block in suggestion.blocks:\n",
+    "        print(plan_block.block.template)\n",
+    "        print(plan_block.queries)\n",
+    "        print(\"==================\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This looks pretty good! We can also use the client to automatically accept and apply, or reject, these suggestions.\n",
+    "\n",
+    "This will (locally) keep track of the history of changes, so that future suggestions can be based on the previous changes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for suggestion in suggestions:\n",
+    "    await report_client.aaccept_edit(suggestion)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "What effect did that have on the tracked local history? Let's see!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[EditAction(block_idx=2, old_content='## Details\\n\\n{details_content}\\n\\nField: details_content, Prompt: Provide detailed information about the Transformer model architecture and its applications, Context: Include information about:\\n- The attention mechanism implementation\\n- Advantages over recurrent and convolutional models\\n- Performance in machine translation tasks\\n- Training efficiency improvements\\nDepends on: none', new_content='\\n## Architecture Details\\n\\n{architecture_content}\\n\\n\\nField: architecture_content, Prompt: Describe the technical details of the Transformer model architecture, Context: Focus on:\\n- Core components of the Transformer architecture\\n- Self-attention mechanism implementation\\n- Multi-head attention details\\n- Position encoding approach\\n- Feed-forward network structure\\nDepends on: none', action='approved', timestamp=datetime.datetime(2025, 2, 4, 20, 59, 55, 773558)),\n",
+       " EditAction(block_idx=3, old_content='[No old content]', new_content='\\n## Performance and Applications\\n\\n{applications_content}\\n\\n\\nField: applications_content, Prompt: Explain the practical applications and performance advantages of the Transformer model, Context: Cover:\\n- Comparison with RNN and CNN models\\n- Machine translation results and benchmarks\\n- Training efficiency improvements\\n- Real-world applications and use cases\\n- Scalability benefits\\nDepends on: previous', action='approved', timestamp=datetime.datetime(2025, 2, 4, 20, 59, 55, 773687))]"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "report_client.edit_history"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[Message(role=<MessageRole.USER: 'user'>, content='Can you split the details section into two sections?', timestamp=datetime.datetime(2025, 2, 4, 20, 59, 47, 754848)),\n",
+       " Message(role=<MessageRole.ASSISTANT: 'assistant'>, content=\"\\nI'll help you break down the details section into two distinct parts - one focusing on the architecture and another on the practical applications and performance. This will make the content more organized and easier to follow. The original block at index 2 will be replaced with these two new sections.\\n\", timestamp=datetime.datetime(2025, 2, 4, 20, 59, 55, 482070))]"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "report_client.chat_history"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "These two items are used to provide context for future suggestions! You can always clear this, or provide your own history."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# report_client.suggest_edits(\"....\", chat_history=[{\"role\": \"user\", \"content\": \"...\"}, ...])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4. Get the final report\n",
+    "\n",
+    "Now that we have a plan, we can kick off generation of the final report."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# kicks off report generation\n",
+    "await report_client.aupdate_plan(action=\"approve\")\n",
+    "\n",
+    "# waits for report generation to complete\n",
+    "report = await report_client.await_completion(\n",
+    "    timeout=10000,\n",
+    "    poll_interval=10,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "# Attention Is All You Need: A Pure Attention-Based Architecture for Neural Machine Translation\n",
+      "\n",
+      "## TLDR\n",
+      "\n",
+      "The Transformer introduced a revolutionary architecture that relies entirely on attention mechanisms, eliminating the need for recurrence or convolution in sequence processing. Its key innovations include multi-head self-attention for parallel processing of input sequences, scaled dot-product attention for efficient computation, and positional encodings for sequence order awareness. The model achieved breakthrough results in machine translation (28.4 BLEU on English-to-German, 41.8 BLEU on English-to-French) while requiring significantly less training time than previous approaches, training in 3.5 days on 8 GPUs. This architecture demonstrated that attention mechanisms alone are sufficient for state-of-the-art sequence modeling, setting a new direction for natural language processing.\n",
+      "\n",
+      "\n",
+      "## Architecture Details\n",
+      "\n",
+      "The Transformer architecture represents a groundbreaking approach to sequence processing, built entirely on attention mechanisms without recurrence or convolution. Here are its key technical details:\n",
+      "\n",
+      "Core Components:\n",
+      "- Encoder-decoder architecture with stacked self-attention and point-wise feed-forward layers\n",
+      "- Each layer contains two main sub-layers: multi-head self-attention mechanism and position-wise feed-forward network\n",
+      "- Layer normalization and residual connections between sub-layers\n",
+      "- No recurrent or convolutional elements, enabling parallel processing\n",
+      "\n",
+      "Self-Attention Mechanism:\n",
+      "- Processes relationships between all positions in a sequence simultaneously\n",
+      "- Computes attention weights using queries, keys, and values derived from input representations\n",
+      "- Implements scaled dot-product attention to prevent gradient issues with large input dimensions\n",
+      "- Allows direct modeling of dependencies regardless of positional distance\n",
+      "- Uses masking in decoder to prevent leftward information flow and maintain auto-regressive property\n",
+      "\n",
+      "Multi-Head Attention:\n",
+      "- Employs multiple attention heads operating in parallel\n",
+      "- Each head processes information in different representation subspaces\n",
+      "- Three types of attention applications:\n",
+      "  1. Encoder self-attention (all positions attend to each other)\n",
+      "  2. Decoder self-attention (each position attends to previous positions)\n",
+      "  3. Encoder-decoder attention (decoder queries attend to encoder outputs)\n",
+      "- Counteracts reduced resolution from attention averaging through parallel processing\n",
+      "\n",
+      "Position-wise Feed-Forward Network:\n",
+      "- Applied identically to each position separately\n",
+      "- Consists of two linear transformations with ReLU activation\n",
+      "- Structure: FFN(x) = max(0, xW1 + b1)W2 + b2\n",
+      "- Input and output dimensionality: dmodel = 512\n",
+      "- Inner-layer dimensionality: dff = 2048\n",
+      "- Parameters vary between layers but remain constant across positions\n",
+      "\n",
+      "Position Encoding:\n",
+      "- Adds positional information to input embeddings\n",
+      "- Enables the model to consider sequential order without recurrence\n",
+      "- Implements sinusoidal position encodings to allow model to attend to relative positions\n",
+      "- Maintains constant number of operations between any two positions, unlike convolutional approaches\n",
+      "- Allows effective modeling of both local and long-range dependencies\n",
+      "\n",
+      "\n",
+      "\n",
+      "## Performance and Applications\n",
+      "\n",
+      "The Transformer model demonstrates significant performance advantages and practical applications across multiple domains:\n",
+      "\n",
+      "Performance Advantages over RNN/CNN Models:\n",
+      "- Eliminates sequential computation constraints present in RNNs, enabling superior parallelization\n",
+      "- Reduces operations needed for relating distant positions to a constant number, compared to linear/logarithmic scaling in CNNs\n",
+      "- Processes all input and output positions simultaneously through self-attention mechanisms\n",
+      "- Achieves state-of-the-art results while requiring significantly less computational resources\n",
+      "\n",
+      "Machine Translation Benchmarks:\n",
+      "- WMT 2014 English-to-German: 28.4 BLEU score, exceeding previous best results by over 2 BLEU points\n",
+      "- WMT 2014 English-to-French: 41.8 BLEU score (single-model state-of-the-art)\n",
+      "- Surpasses performance of existing model ensembles in translation tasks\n",
+      "\n",
+      "Training Efficiency:\n",
+      "- Requires only 3.5 days of training on eight GPUs for state-of-the-art performance\n",
+      "- Achieves superior results at \"a small fraction of the training costs\" compared to previous models\n",
+      "- Enables significantly faster training through parallel processing of input/output sequences\n",
+      "- Can reach production-quality performance in as little as twelve hours on modern GPU hardware\n",
+      "\n",
+      "Real-world Applications:\n",
+      "- Machine translation systems\n",
+      "- Natural language understanding tasks\n",
+      "- Reading comprehension\n",
+      "- Abstractive summarization\n",
+      "- Text entailment analysis\n",
+      "- Constituency parsing (achieving 92.7 F1 score in semi-supervised settings)\n",
+      "- Adaptable to both large and limited training data scenarios\n",
+      "\n",
+      "Scalability Benefits:\n",
+      "- Highly parallelizable architecture enables efficient scaling across multiple GPUs\n",
+      "- Constant computational complexity for relating any input/output positions\n",
+      "- Effective handling of long-range dependencies in sequences\n",
+      "- Maintains performance quality while scaling to larger datasets and model sizes\n",
+      "- Generalizes well across different tasks and domains without architectural changes\n",
+      "- Supports efficient inference and deployment in production environments\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "report_text = \"\\n\\n\".join([block.template for block in report.blocks])\n",
+    "print(report_text)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 5. Edit the final report\n",
+    "\n",
+    "Now that we have a report, we can edit it.\n",
+    "\n",
+    "We can use the `asuggest_edits` method to get suggestions for edits, and then use the `aaccept_edit`/`areject_edit` methods to apply them.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Justification for change: \n",
+      "I'd suggest changing \"TLDR\" to \"Executive Summary\" which is more appropriate for a professional or academic report. This term is widely used in formal documents and better reflects the nature of this concise overview section while maintaining the same function of providing a quick summary of the key points.\n",
+      "\n",
+      "Proposed changes:\n",
+      "## Executive Summary\n",
+      "\n",
+      "The Transformer introduced a revolutionary architecture that relies entirely on attention mechanisms, eliminating the need for recurrence or convolution in sequence processing. Its key innovations include multi-head self-attention for parallel processing of input sequences, scaled dot-product attention for efficient computation, and positional encodings for sequence order awareness. The model achieved breakthrough results in machine translation (28.4 BLEU on English-to-German, 41.8 BLEU on English-to-French) while requiring significantly less training time than previous approaches, training in 3.5 days on 8 GPUs. This architecture demonstrated that attention mechanisms alone are sufficient for state-of-the-art sequence modeling, setting a new direction for natural language processing.\n",
+      "==================\n"
+     ]
+    }
+   ],
+   "source": [
+    "suggestions = await report_client.asuggest_edits(\n",
+    "    \"Can you change the TLDR header to something more professional?\"\n",
+    ")\n",
+    "for suggestion in suggestions:\n",
+    "    print(\"Justification for change:\", suggestion.justification)\n",
+    "    print(\"Proposed changes:\")\n",
+    "    for block in suggestion.blocks:\n",
+    "        print(block.template)\n",
+    "        print(\"==================\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Changing to \"Executive Summary\" sounds reasonable, lets accept that!\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for suggestion in suggestions:\n",
+    "    await report_client.aaccept_edit(suggestion)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 7. Print the final report\n",
+    "\n",
+    "Now that we have a report, we can print it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "# Attention Is All You Need: A Pure Attention-Based Architecture for Neural Machine Translation\n",
+      "\n",
+      "## Executive Summary\n",
+      "\n",
+      "The Transformer introduced a revolutionary architecture that relies entirely on attention mechanisms, eliminating the need for recurrence or convolution in sequence processing. Its key innovations include multi-head self-attention for parallel processing of input sequences, scaled dot-product attention for efficient computation, and positional encodings for sequence order awareness. The model achieved breakthrough results in machine translation (28.4 BLEU on English-to-German, 41.8 BLEU on English-to-French) while requiring significantly less training time than previous approaches, training in 3.5 days on 8 GPUs. This architecture demonstrated that attention mechanisms alone are sufficient for state-of-the-art sequence modeling, setting a new direction for natural language processing.\n",
+      "\n",
+      "\n",
+      "## Architecture Details\n",
+      "\n",
+      "The Transformer architecture represents a groundbreaking approach to sequence processing, built entirely on attention mechanisms without recurrence or convolution. Here are its key technical details:\n",
+      "\n",
+      "Core Components:\n",
+      "- Encoder-decoder architecture with stacked self-attention and point-wise feed-forward layers\n",
+      "- Each layer contains two main sub-layers: multi-head self-attention mechanism and position-wise feed-forward network\n",
+      "- Layer normalization and residual connections between sub-layers\n",
+      "- No recurrent or convolutional elements, enabling parallel processing\n",
+      "\n",
+      "Self-Attention Mechanism:\n",
+      "- Processes relationships between all positions in a sequence simultaneously\n",
+      "- Computes attention weights using queries, keys, and values derived from input representations\n",
+      "- Implements scaled dot-product attention to prevent gradient issues with large input dimensions\n",
+      "- Allows direct modeling of dependencies regardless of positional distance\n",
+      "- Uses masking in decoder to prevent leftward information flow and maintain auto-regressive property\n",
+      "\n",
+      "Multi-Head Attention:\n",
+      "- Employs multiple attention heads operating in parallel\n",
+      "- Each head processes information in different representation subspaces\n",
+      "- Three types of attention applications:\n",
+      "  1. Encoder self-attention (all positions attend to each other)\n",
+      "  2. Decoder self-attention (each position attends to previous positions)\n",
+      "  3. Encoder-decoder attention (decoder queries attend to encoder outputs)\n",
+      "- Counteracts reduced resolution from attention averaging through parallel processing\n",
+      "\n",
+      "Position-wise Feed-Forward Network:\n",
+      "- Applied identically to each position separately\n",
+      "- Consists of two linear transformations with ReLU activation\n",
+      "- Structure: FFN(x) = max(0, xW1 + b1)W2 + b2\n",
+      "- Input and output dimensionality: dmodel = 512\n",
+      "- Inner-layer dimensionality: dff = 2048\n",
+      "- Parameters vary between layers but remain constant across positions\n",
+      "\n",
+      "Position Encoding:\n",
+      "- Adds positional information to input embeddings\n",
+      "- Enables the model to consider sequential order without recurrence\n",
+      "- Implements sinusoidal position encodings to allow model to attend to relative positions\n",
+      "- Maintains constant number of operations between any two positions, unlike convolutional approaches\n",
+      "- Allows effective modeling of both local and long-range dependencies\n",
+      "\n",
+      "\n",
+      "\n",
+      "## Performance and Applications\n",
+      "\n",
+      "The Transformer model demonstrates significant performance advantages and practical applications across multiple domains:\n",
+      "\n",
+      "Performance Advantages over RNN/CNN Models:\n",
+      "- Eliminates sequential computation constraints present in RNNs, enabling superior parallelization\n",
+      "- Reduces operations needed for relating distant positions to a constant number, compared to linear/logarithmic scaling in CNNs\n",
+      "- Processes all input and output positions simultaneously through self-attention mechanisms\n",
+      "- Achieves state-of-the-art results while requiring significantly less computational resources\n",
+      "\n",
+      "Machine Translation Benchmarks:\n",
+      "- WMT 2014 English-to-German: 28.4 BLEU score, exceeding previous best results by over 2 BLEU points\n",
+      "- WMT 2014 English-to-French: 41.8 BLEU score (single-model state-of-the-art)\n",
+      "- Surpasses performance of existing model ensembles in translation tasks\n",
+      "\n",
+      "Training Efficiency:\n",
+      "- Requires only 3.5 days of training on eight GPUs for state-of-the-art performance\n",
+      "- Achieves superior results at \"a small fraction of the training costs\" compared to previous models\n",
+      "- Enables significantly faster training through parallel processing of input/output sequences\n",
+      "- Can reach production-quality performance in as little as twelve hours on modern GPU hardware\n",
+      "\n",
+      "Real-world Applications:\n",
+      "- Machine translation systems\n",
+      "- Natural language understanding tasks\n",
+      "- Reading comprehension\n",
+      "- Abstractive summarization\n",
+      "- Text entailment analysis\n",
+      "- Constituency parsing (achieving 92.7 F1 score in semi-supervised settings)\n",
+      "- Adaptable to both large and limited training data scenarios\n",
+      "\n",
+      "Scalability Benefits:\n",
+      "- Highly parallelizable architecture enables efficient scaling across multiple GPUs\n",
+      "- Constant computational complexity for relating any input/output positions\n",
+      "- Effective handling of long-range dependencies in sequences\n",
+      "- Maintains performance quality while scaling to larger datasets and model sizes\n",
+      "- Generalizes well across different tasks and domains without architectural changes\n",
+      "- Supports efficient inference and deployment in production environments\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "report_response = await report_client.aget()\n",
+    "report_text = \"\\n\\n\".join([block.template for block in report_response.report.blocks])\n",
+    "print(report_text)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can also see the sources for each block!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.99687636\n",
+      "# Abstract\n",
+      "\n",
+      "The dominant sequence transduction models are based on complex recurrent or convolutiona\n",
+      "==================\n",
+      "0.99591404\n",
+      "# 2 Background\n",
+      "\n",
+      "The goal of reducing sequential computation also forms the foundation of the Extende\n",
+      "==================\n",
+      "0.9951325\n",
+      "# 1 Introduction\n",
+      "\n",
+      "Recurrent neural networks, long short-term memory [13] and gated recurrent [7] neu\n",
+      "==================\n",
+      "0.99442345\n",
+      "# 7 Conclusion\n",
+      "\n",
+      "In this work, we presented the Transformer, the first sequence transduction model ba\n",
+      "==================\n",
+      "0.9967649\n",
+      "# 3.2.3 Applications of Attention in our Model\n",
+      "\n",
+      "The Transformer uses multi-head attention in three d\n",
+      "==================\n",
+      "0.99533635\n",
+      "# 2 Background\n",
+      "\n",
+      "The goal of reducing sequential computation also forms the foundation of the Extende\n",
+      "==================\n",
+      "0.9935868\n",
+      "# Abstract\n",
+      "\n",
+      "The dominant sequence transduction models are based on complex recurrent or convolutiona\n",
+      "==================\n",
+      "0.98780584\n",
+      "# Outputs\n",
+      "\n",
+      "(shifted right)\n",
+      "\n",
+      "Figure 1: The Transformer - model architecture.\n",
+      "\n",
+      "The Transformer follows\n",
+      "==================\n",
+      "0.9205043\n",
+      "# 3.3 Position-wise Feed-Forward Networks\n",
+      "\n",
+      "In addition to attention sub-layers, each of the layers i\n",
+      "==================\n",
+      "0.79581684\n",
+      "# 1 Introduction\n",
+      "\n",
+      "Recurrent neural networks, long short-term memory [13] and gated recurrent [7] neu\n",
+      "==================\n",
+      "0.9946774\n",
+      "# Abstract\n",
+      "\n",
+      "The dominant sequence transduction models are based on complex recurrent or convolutiona\n",
+      "==================\n",
+      "0.97079873\n",
+      "# 7 Conclusion\n",
+      "\n",
+      "In this work, we presented the Transformer, the first sequence transduction model ba\n",
+      "==================\n",
+      "0.9535353\n",
+      "# 6.3 English Constituency Parsing\n",
+      "\n",
+      "To evaluate if the Transformer can generalize to other tasks we \n",
+      "==================\n",
+      "0.9514138\n",
+      "# 2 Background\n",
+      "\n",
+      "The goal of reducing sequential computation also forms the foundation of the Extende\n",
+      "==================\n",
+      "0.9790758\n",
+      "# 1 Introduction\n",
+      "\n",
+      "Recurrent neural networks, long short-term memory [13] and gated recurrent [7] neu\n",
+      "==================\n",
+      "0.92262185\n",
+      "# Outputs\n",
+      "\n",
+      "(shifted right)\n",
+      "\n",
+      "Figure 1: The Transformer - model architecture.\n",
+      "\n",
+      "The Transformer follows\n",
+      "==================\n"
+     ]
+    }
+   ],
+   "source": [
+    "for block in report_response.report.blocks:\n",
+    "    # Each block has a list of sources, which are the nodes that were used to generate the block\n",
+    "    for source in block.sources:\n",
+    "        print(source.score)\n",
+    "        print(source.node.text[:100])\n",
+    "        print(\"==================\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "llama-parse-aNC435Vv-py3.10",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

extract.md

@@ -0,0 +1,186 @@
+# LlamaExtract
+
+> **⚠️ EXPERIMENTAL**
+> This library is under active development with frequent breaking changes. APIs and functionality may change significantly between versions. If you're interested in being an early adopter, please contact us at [support@llamaindex.ai](mailto:support@llamaindex.ai) or join our [Discord](https://discord.com/invite/eN6D2HQ4aX).
+
+LlamaExtract provides a simple API for extracting structured data from unstructured documents like PDFs, text files and images (upcoming).
+
+## Quick Start
+
+```python
+from llama_cloud_services import LlamaExtract
+from pydantic import BaseModel, Field
+
+# Initialize client
+extractor = LlamaExtract()
+
+
+# Define schema using Pydantic
+class Resume(BaseModel):
+    name: str = Field(description="Full name of candidate")
+    email: str = Field(description="Email address")
+    skills: list[str] = Field(description="Technical skills and technologies")
+
+
+# Create extraction agent
+agent = extractor.create_agent(name="resume-parser", data_schema=Resume)
+
+# Extract data from document
+result = agent.extract("resume.pdf")
+print(result.data)
+```
+
+## Core Concepts
+
+- **Extraction Agents**: Reusable extractors configured with a specific schema and extraction settings.
+- **Data Schema**: Structure definition for the data you want to extract in the form of a JSON schema or a Pydantic model.
+- **Extraction Jobs**: Asynchronous extraction tasks that can be monitored.
+
+## Defining Schemas
+
+Schemas can be defined using either Pydantic models or JSON Schema:
+
+### Using Pydantic (Recommended)
+
+```python
+from pydantic import BaseModel, Field
+from typing import List, Optional
+
+
+class Experience(BaseModel):
+    company: str = Field(description="Company name")
+    title: str = Field(description="Job title")
+    start_date: Optional[str] = Field(description="Start date of employment")
+    end_date: Optional[str] = Field(description="End date of employment")
+
+
+class Resume(BaseModel):
+    name: str = Field(description="Candidate name")
+    experience: List[Experience] = Field(description="Work history")
+```
+
+### Using JSON Schema
+
+```python
+schema = {
+    "type": "object",
+    "properties": {
+        "name": {"type": "string", "description": "Candidate name"},
+        "experience": {
+            "type": "array",
+            "description": "Work history",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "company": {
+                        "type": "string",
+                        "description": "Company name",
+                    },
+                    "title": {"type": "string", "description": "Job title"},
+                    "start_date": {
+                        "anyOf": [{"type": "string"}, {"type": "null"}],
+                        "description": "Start date of employment",
+                    },
+                    "end_date": {
+                        "anyOf": [{"type": "string"}, {"type": "null"}],
+                        "description": "End date of employment",
+                    },
+                },
+            },
+        },
+    },
+}
+
+agent = extractor.create_agent(name="resume-parser", data_schema=schema)
+```
+
+### Important restrictions on JSON/Pydantic Schema
+
+_LlamaExtract only supports a subset of the JSON Schema specification._ While limited, it should
+be sufficient for a wide variety of use-cases.
+
+- All fields are required by default. Nullable fields must be explicitly marked as such,
+  using `"anyOf"` with a `"null"` type. See `"start_date"` field above.
+- Root node must be of type `"object"`.
+- Schema nesting must be limited to within 5 levels.
+- The important fields are key names/titles, type and description. Fields for
+  formatting, default values, etc. are not supported.
+- There are other restrictions on number of keys, size of the schema, etc. that you may
+  hit for complex extraction use cases. In such cases, it is worth thinking how to restructure
+  your extraction workflow to fit within these constraints, e.g. by extracting subset of fields
+  and later merging them together.
+
+## Other Extraction APIs
+
+### Batch Processing
+
+Process multiple files asynchronously:
+
+```python
+# Queue multiple files for extraction
+jobs = await agent.queue_extraction(["resume1.pdf", "resume2.pdf"])
+
+# Check job status
+for job in jobs:
+    status = agent.get_extraction_job(job.id).status
+    print(f"Job {job.id}: {status}")
+
+# Get results when complete
+results = [agent.get_extraction_run_for_job(job.id) for job in jobs]
+```
+
+### Updating Schemas
+
+Schemas can be modified and updated after creation:
+
+```python
+# Update schema
+agent.data_schema = new_schema
+
+# Save changes
+agent.save()
+```
+
+### Managing Agents
+
+```python
+# List all agents
+agents = extractor.list_agents()
+
+# Get specific agent
+agent = extractor.get_agent(name="resume-parser")
+
+# Delete agent
+extractor.delete_agent(agent.id)
+```
+
+## Installation
+
+```bash
+pip install llama-extract==0.1.0
+```
+
+## Tips & Best Practices
+
+1. **Schema Design**:
+
+   - Try to limit schema nesting to 3-4 levels.
+   - Make fields optional when data might not always be present. Having required fields may force the model
+     to hallucinate when these fields are not present in the documents.
+   - When you want to extract a variable number of entities, use an `array` type. Note that you cannot use
+     an `array` type for the root node.
+   - Use descriptive field names and detailed descriptions. Use descriptions to pass formatting
+     instructions or few-shot examples.
+   - Start simple and iteratively build your schema to incorporate requirements.
+
+2. **Running Extractions**:
+   - Note that resetting `agent.schema` will not save the schema to the database,
+     until you call `agent.save`, but it will be used for running extractions.
+   - Check job status prior to accessing results. Any extraction error should be available as
+     part of `job.error` or `extraction_run.error` fields for debugging.
+   - Consider async operations (`queue_extraction`) for large-scale extraction once you have finalized your schema.
+
+## Additional Resources
+
+- [Example Notebook](examples/resume_screening.ipynb) - Detailed walkthrough of resume parsing
+- [Discord Community](https://discord.com/invite/eN6D2HQ4aX) - Get help and share feedback

llama_cloud_services/__init__.py

@@ -0,0 +1,13 @@
+from llama_cloud_services.parse import LlamaParse
+from llama_cloud_services.report import ReportClient, LlamaReport
+from llama_cloud_services.extract import LlamaExtract, ExtractionAgent
+from llama_cloud_services.constants import EU_BASE_URL
+
+__all__ = [
+    "LlamaParse",
+    "ReportClient",
+    "LlamaReport",
+    "LlamaExtract",
+    "ExtractionAgent",
+    "EU_BASE_URL",
+]

llama_cloud_services/constants.py

@@ -0,0 +1 @@
+EU_BASE_URL = "https://api.cloud.eu.llamaindex.ai"