clarifai 9.11.0__py3-none-any.whl → 10.0.0__py3-none-any.whl

clarifai/client/app.py

@@ -47,7 +47,7 @@ class App(Lister, BaseClient):
     if url and app_id:
       raise UserError("You can only specify one of url or app_id.")
     if url:
-      user_id, app_id, _, _, _ = ClarifaiUrlHelper.split_clarifai_url(url)
+      user_id, app_id = ClarifaiUrlHelper.split_clarifai_app_url(url)
       kwargs = {'user_id': user_id}
     self.kwargs = {**kwargs, 'id': app_id}
     self.app_info = resources_pb2.App(**self.kwargs)

clarifai/client/input.py

@@ -7,11 +7,13 @@ from concurrent.futures import ThreadPoolExecutor, as_completed
 from multiprocessing import cpu_count
 from typing import Generator, List, Union
 
+import requests
 from clarifai_grpc.grpc.api import resources_pb2, service_pb2  # noqa: F401
 from clarifai_grpc.grpc.api.resources_pb2 import Annotation, Audio, Image, Input, Text, Video
 from clarifai_grpc.grpc.api.status import status_code_pb2, status_pb2
 from google.protobuf.json_format import MessageToDict
 from google.protobuf.struct_pb2 import Struct
+from requests.adapters import HTTPAdapter, Retry
 from tqdm import tqdm
 
 from clarifai.client.base import BaseClient
@@ -306,7 +308,7 @@ class Inputs(Lister, BaseClient):
         >>> from clarifai.client.input import Inputs
         >>> input_protos = Inputs.get_multimodal_input(input_id = 'demo', raw_text = 'What time of day is it?', image_url='https://samples.clarifai.com/metro-north.jpg')
     """
-    if (image_bytes and image_url) or (not image_url and not image_url):
+    if (image_bytes and image_url) or (not image_bytes and not image_url):
       return UserError("Please supply only one of image_bytes or image_url, and not both.")
     if (text_bytes and raw_text) or (not text_bytes and not raw_text):
       return UserError("Please supply only one of text_bytes or raw_text, and not both.")
@@ -729,6 +731,37 @@ class Inputs(Lister, BaseClient):
       raise Exception(response.status)
     self.logger.info("\nInputs Deleted\n%s", response.status)
 
+  def download_inputs(self, inputs: List[Input]) -> List[bytes]:
+    """Download list of input objects from the app.
+
+    Args:
+        input_ids (Input): List of input objects to download.
+
+    Example:
+        >>> from clarifai.client.user import User
+        >>> input_obj = User(user_id="user_id").app(app_id="app_id").inputs()
+        >>> input_obj.download_inputs(list(input_obj.list_inputs()))
+    """
+    if not isinstance(inputs, list):
+      raise UserError("input_ids must be a list of input ids")
+    final_inputs = []
+    #initiate session
+    session = requests.Session()
+    retries = Retry(total=3, backoff_factor=0.1, status_forcelist=[500, 502, 503, 504])
+    session.mount('https://', HTTPAdapter(max_retries=retries))
+    session.headers.update({'Authorization': self.metadata[0][1]})
+    # download inputs
+    data_types = ['image', 'video', 'audio', 'text']
+    for input in inputs:
+      for data_type in data_types:
+        url = getattr(input.data, data_type).url
+        if url:
+          response = session.get(url, stream=True)
+          if response.status_code == 200:
+            final_inputs.append(response.content)
+
+    return final_inputs
+
   def list_inputs(self,
                   dataset_id: str = None,
                   page_no: int = None,

clarifai/client/search.py

@@ -18,8 +18,8 @@ from clarifai.schema.search import get_schema
 class Search(Lister, BaseClient):
 
   def __init__(self,
-               user_id,
-               app_id,
+               user_id: str,
+               app_id: str,
                top_k: int = DEFAULT_TOP_K,
                metric: str = DEFAULT_SEARCH_METRIC,
                base_url: str = "https://api.clarifai.com",
@@ -208,7 +208,9 @@ class Search(Lister, BaseClient):
         >>> search = Search(user_id='user_id', app_id='app_id', top_k=1, metric='cosine')
         >>> res = search.query(ranks=[{'image_url': 'https://samples.clarifai.com/dog.tiff'}])
 
-    Note: For more detailed search examples, please refer to [examples](https://github.com/Clarifai/examples/tree/main/search).
+    Note:
+        For schema of rank and filter, please refer to [schema](https://github.com/Clarifai/clarifai-python/tree/master/clarifai/schema/search.py).
+        For more detailed search examples, please refer to [examples](https://github.com/Clarifai/examples/tree/main/search).
     """
     try:
       self.rank_filter_schema.validate(ranks)
@@ -216,7 +218,13 @@ class Search(Lister, BaseClient):
     except SchemaError as err:
       raise UserError(f"Invalid rank or filter input: {err}")
 
-    ## Calls PostInputsSearches for input filters
+    # For each rank, create a Rank proto message
+    rank_annot_proto = []
+    for rank_dict in ranks:
+      rank_annot_proto.append(self._get_annot_proto(**rank_dict))
+    all_ranks = [resources_pb2.Rank(annotation=rank_annot) for rank_annot in rank_annot_proto]
+
+    # Calls PostInputsSearches for annotation ranks, input filters
     if any(["input" in k for k in filters[0].keys()]):
       filters_input_proto = []
       for filter_dict in filters:
@@ -228,20 +236,18 @@ class Search(Lister, BaseClient):
           user_app_id=self.user_app_id,
           searches=[
               resources_pb2.Search(
-                  query=resources_pb2.Query(filters=all_filters), metric=self.metric_distance)
+                  query=resources_pb2.Query(ranks=all_ranks, filters=all_filters),
+                  metric=self.metric_distance)
           ])
 
       return self.list_all_pages_generator(self.STUB.PostInputsSearches,
                                            service_pb2.PostInputsSearchesRequest, request_data)
 
     # Calls PostAnnotationsSearches for annotation ranks, filters
-    rank_annot_proto, filters_annot_proto = [], []
-    for rank_dict in ranks:
-      rank_annot_proto.append(self._get_annot_proto(**rank_dict))
+    filters_annot_proto = []
     for filter_dict in filters:
       filters_annot_proto.append(self._get_annot_proto(**filter_dict))
 
-    all_ranks = [resources_pb2.Rank(annotation=rank_annot) for rank_annot in rank_annot_proto]
     all_filters = [
         resources_pb2.Filter(annotation=filter_annot) for filter_annot in filters_annot_proto
     ]

clarifai/client/workflow.py

@@ -58,11 +58,12 @@ class Workflow(Lister, BaseClient):
     BaseClient.__init__(self, user_id=self.user_id, app_id=self.app_id, base=base_url, pat=pat)
     Lister.__init__(self)
 
-  def predict(self, inputs: List[Input]):
+  def predict(self, inputs: List[Input], workflow_state_id: str = None):
     """Predicts the workflow based on the given inputs.
 
     Args:
         inputs (list[Input]): The inputs to predict.
+        workflow_state_id (str): key for the workflow state cache that stores the workflow node predictions.
     """
     if len(inputs) > MAX_WORKFLOW_PREDICT_INPUTS:
       raise UserError(f"Too many inputs. Max is {MAX_WORKFLOW_PREDICT_INPUTS}."
@@ -74,6 +75,9 @@ class Workflow(Lister, BaseClient):
         inputs=inputs,
         output_config=self.output_config)
 
+    if workflow_state_id:
+      request.workflow_state.id = workflow_state_id
+
     start_time = time.time()
     backoff_iterator = BackoffIterator()
 
@@ -81,7 +85,7 @@ class Workflow(Lister, BaseClient):
       response = self._grpc_request(self.STUB.PostWorkflowResults, request)
 
       if response.status.code == status_code_pb2.MODEL_DEPLOYING and \
-          time.time() - start_time < 60:
+          time.time() - start_time < 60*10:  # 10 minutes
         self.logger.info(f"{self.id} Workflow is still deploying, please wait...")
         time.sleep(next(backoff_iterator))
         continue

clarifai/constants/rag.py

@@ -0,0 +1 @@
+MAX_UPLOAD_BATCH_SIZE = 128

clarifai/models/model_serving/README.md

@@ -151,7 +151,7 @@ Additional methods can be added to this script's `Infer` class by the user as de
 - [Model types docs](docs/model_types.md)
 - [Model Output types docs](docs/output.md)
 - [Dependencies](docs/dependencies.md)
-- [Examples](examples/)
+- [Examples](https://github.com/Clarifai/examples)
 - [Custom Configs](docs/custom_config.md/)
 
 ## Prerequisites

clarifai/models/model_serving/models/default_test.py

@@ -67,6 +67,9 @@ class DefaultTestInferenceModel(unittest.TestCase):
                   is_instance_kind_gpu: bool = True,
                   inference_parameters: Union[str, Dict[str, Any]] = ""):
     import sys
+    #
+    if 'inference' in sys.modules:
+      del sys.modules['inference']
     sys.path.append(repo_version_dir)
     self.model_type = model_type
     self.is_instance_kind_gpu = is_instance_kind_gpu

clarifai/rag/__init__.py

@@ -0,0 +1,3 @@
+from .rag import RAG
+
+__all__ = ["RAG"]

clarifai/rag/rag.py

@@ -0,0 +1,261 @@
+import uuid
+from datetime import datetime
+from typing import List
+
+import yaml
+from clarifai_grpc.grpc.api import resources_pb2  # noqa: F401
+from google.protobuf.struct_pb2 import Struct
+
+from clarifai.client.app import App
+from clarifai.client.input import Inputs
+from clarifai.client.model import Model
+from clarifai.client.user import User
+from clarifai.client.workflow import Workflow
+from clarifai.constants.rag import MAX_UPLOAD_BATCH_SIZE
+from clarifai.errors import UserError
+from clarifai.rag.utils import (convert_messages_to_str, format_assistant_message, load_documents,
+                                split_document)
+from clarifai.utils.logging import get_logger
+
+
+class RAG:
+  """
+    RAG is a class for Retrieval Augmented Generation.
+
+    Example:
+        >>> from clarifai.rag import RAG
+        >>> rag_agent = RAG()
+    """
+  chat_state_id = None
+
+  def __init__(self,
+               workflow_url: str = None,
+               workflow: Workflow = None,
+               base_url: str = "https://api.clarifai.com",
+               pat: str = None,
+               **kwargs):
+    """Initialize an empty or existing RAG.
+    """
+    self.logger = get_logger(logger_level="INFO", name=__name__)
+    if workflow_url is not None and workflow is None:
+      self.logger.info("workflow_url:%s", workflow_url)
+      w = Workflow(workflow_url, base_url=base_url, pat=pat)
+      self._prompt_workflow = w
+      self._app = App(app_id=w.app_id, base_url=w.base, pat=w.pat)
+    elif workflow_url is None and workflow is not None:
+      self._prompt_workflow = workflow
+      self._app = App(app_id=workflow.app_id, base_url=workflow.base, pat=workflow.pat)
+
+  @classmethod
+  def setup(cls,
+            user_id: str = None,
+            llm_url: str = "https://clarifai.com/mistralai/completion/models/mistral-7B-Instruct",
+            base_workflow: str = "Text",
+            workflow_yaml_filename: str = 'prompter_wf.yaml',
+            base_url: str = "https://api.clarifai.com",
+            pat: str = None,
+            **kwargs):
+    """Creates an app with `Text` as base workflow, create prompt model, create prompt workflow.
+
+    Example:
+        >>> from clarifai.rag import RAG
+        >>> rag_agent = RAG.setup()
+    """
+    user = User(user_id=user_id, base_url=base_url, pat=pat)
+    llm = Model(llm_url)
+
+    params = Struct()
+    params.update({
+        "prompt_template":
+            "Context information is below:\n{data.hits}\nGiven the context information and not prior knowledge, answer the query.\nQuery: {data.text.raw}\nAnswer: "
+    })
+    prompter_model_params = {"params": params}
+
+    ## Create an App
+    now_ts = str(int(datetime.now().timestamp()))
+    app_id = f"rag_app_{now_ts}"
+    app = user.create_app(app_id=app_id, base_workflow=base_workflow)
+
+    ## Create rag-prompter model and version
+    prompter_model = app.create_model(
+        model_id=f"rag_prompter_{now_ts}", model_type_id="rag-prompter")
+    prompter_model = prompter_model.create_version(output_info=prompter_model_params)
+
+    ## Generate a tmp yaml file for workflow creation
+    workflow_id = f"rag-wf-{now_ts}"
+    workflow_dict = {
+        "workflow": {
+            "id":
+                workflow_id,
+            "nodes": [{
+                "id": "rag-prompter",
+                "model": {
+                    "model_id": prompter_model.id,
+                    "model_version_id": prompter_model.model_version.id
+                }
+            }, {
+                "id": "llm",
+                "model": {
+                    "model_id": llm.id,
+                    "user_id": llm.user_id,
+                    "app_id": llm.app_id
+                },
+                "node_inputs": [{
+                    "node_id": "rag-prompter"
+                }]
+            }]
+        }
+    }
+    with open(workflow_yaml_filename, 'w') as out_file:
+      yaml.dump(workflow_dict, out_file, default_flow_style=False)
+
+    ## Create prompt workflow
+    wf = app.create_workflow(config_filepath=workflow_yaml_filename)
+    del user, llm, prompter_model, prompter_model_params
+    return cls(workflow=wf)
+
+  def upload(self,
+             file_path: str = None,
+             folder_path: str = None,
+             url: str = None,
+             batch_size: int = 128,
+             chunk_size: int = 1024,
+             chunk_overlap: int = 200,
+             **kwargs) -> None:
+    """Uploads documents to the app.
+        - Read from a local directory or public url or local filename.
+        - Parse the document(s) into chunks.
+        - Ingest chunks into the app with metadata.
+
+    Args:
+        file_path str: File path to the document.
+        folder_path str: Folder path to the documents.
+        url str: Public url to the document.
+        batch_size int: Batch size for uploading.
+        chunk_size int: Chunk size for splitting the document.
+        chunk_overlap int: The token overlap of each chunk when splitting.
+        **kwargs: Additional arguments for the SentenceSplitter. Refer https://docs.llamaindex.ai/en/stable/api/llama_index.node_parser.SentenceSplitter.html
+
+    Example:
+        >>> from clarifai.rag import RAG
+        >>> rag_agent = RAG.setup()
+        >>> rag_agent.upload(folder_path = "~/work/docs")
+        >>> rag_agent.upload(file_path = "~/work/docs/manual.pdf")
+    """
+    #set batch size
+    if batch_size > MAX_UPLOAD_BATCH_SIZE:
+      raise ValueError(f"batch_size cannot be greater than {MAX_UPLOAD_BATCH_SIZE}")
+
+    #check if only one of file_path, folder_path, or url is specified
+    if file_path and (folder_path or url):
+      raise ValueError("Only one of file_path, folder_path, or url can be specified.")
+    if folder_path and (file_path or url):
+      raise ValueError("Only one of file_path, folder_path, or url can be specified.")
+    if url and (file_path or folder_path):
+      raise ValueError("Only one of file_path, folder_path, or url can be specified.")
+
+    #loading documents
+    documents = load_documents(file_path=file_path, folder_path=folder_path, url=url)
+
+    #splitting documents into chunks
+    text_chunks = []
+    metadata = []
+
+    #iterate through documents
+    for doc in documents:
+      cur_text_chunks = split_document(
+          text=doc.text, chunk_size=chunk_size, chunk_overlap=chunk_overlap, **kwargs)
+      text_chunks.extend(cur_text_chunks)
+      metadata.extend([doc.metadata for _ in range(len(cur_text_chunks))])
+      #if batch size is reached, upload the batch
+      if len(text_chunks) > batch_size:
+        for idx in range(0, len(text_chunks), batch_size):
+          if idx + batch_size > len(text_chunks):
+            continue
+          batch_texts = text_chunks[0:batch_size]
+          batch_ids = [uuid.uuid4().hex for _ in range(batch_size)]
+          #metadata
+          batch_metadatas = metadata[0:batch_size]
+          meta_list = []
+          for meta in batch_metadatas:
+            meta_struct = Struct()
+            meta_struct.update(meta)
+            meta_list.append(meta_struct)
+          del batch_metadatas
+          #creating input proto
+          input_batch = [
+              self._app.inputs().get_text_input(
+                  input_id=batch_ids[i],
+                  raw_text=text,
+                  metadata=meta_list[i],
+              ) for i, text in enumerate(batch_texts)
+          ]
+          #uploading input with metadata
+          self._app.inputs().upload_inputs(inputs=input_batch)
+          #delete uploaded chunks
+          del text_chunks[0:batch_size]
+          del metadata[0:batch_size]
+
+    #uploading the remaining chunks
+    if len(text_chunks) > 0:
+      batch_size = len(text_chunks)
+      batch_ids = [uuid.uuid4().hex for _ in range(batch_size)]
+      #metadata
+      batch_metadatas = metadata[0:batch_size]
+      meta_list = []
+      for meta in batch_metadatas:
+        meta_struct = Struct()
+        meta_struct.update(meta)
+        meta_list.append(meta_struct)
+      del batch_metadatas
+      #creating input proto
+      input_batch = [
+          self._app.inputs().get_text_input(
+              input_id=batch_ids[i],
+              raw_text=text,
+              metadata=meta_list[i],
+          ) for i, text in enumerate(text_chunks)
+      ]
+      #uploading input with metadata
+      self._app.inputs().upload_inputs(inputs=input_batch)
+      del text_chunks
+      del metadata
+
+  def chat(self, messages: List[dict], client_manage_state: bool = False) -> List[dict]:
+    """Chat interface in OpenAI API format.
+
+    Args:
+        messages List[dict]: A list of dictionary in the following format:
+        ```
+        [
+          {"role": "user", "content": "Hello there."},
+          {"role": "assistant", "content": "Hi, I'm Claude. How can I help you?"},
+          {"role": "user", "content": "Can you explain LLMs in plain English?"},
+        ]
+        ```
+        client_manage_state (bool): Whether the client will handle chat state management. Default is false.
+
+    This will pass back the workflow state ID for the server to store chat state.
+    """
+    if client_manage_state:
+      single_prompt = convert_messages_to_str(messages)
+      input_proto = Inputs._get_proto("", "", text_pb=resources_pb2.Text(raw=single_prompt))
+      response = self._prompt_workflow.predict([input_proto])
+      messages.append(format_assistant_message(response.results[0].outputs[-1].data.text.raw))
+      return messages
+
+    # server-side state management
+    message = messages[-1].get("content", "")
+    if len(message) == 0:
+      raise UserError("Empty message supplied.")
+
+    # get chat state id
+    chat_state_id = "init" if self.chat_state_id is None else self.chat_state_id
+
+    # call predict
+    input_proto = Inputs._get_proto("", "", text_pb=resources_pb2.Text(raw=message))
+    response = self._prompt_workflow.predict([input_proto], workflow_state_id=chat_state_id)
+
+    # store chat state id
+    self.chat_state_id = response.workflow_state.id
+    return [format_assistant_message(response.results[0].outputs[-1].data.text.raw)]

clarifai/rag/utils.py

@@ -0,0 +1,102 @@
+import io
+from pathlib import Path
+from typing import List
+
+import requests
+from llama_index import Document, SimpleDirectoryReader, download_loader
+from llama_index.node_parser.text import SentenceSplitter
+from pypdf import PdfReader
+
+
+## TODO: Make this token-aware.
+def convert_messages_to_str(messages: List[dict]) -> str:
+  """convert messages in OpenAI API format into a single string.
+
+    Args:
+        messages List[dict]: A list of dictionary in the following format:
+        ```
+        [
+          {"role": "user", "content": "Hello there."},
+          {"role": "assistant", "content": "Hi, I'm Claude. How can I help you?"},
+          {"role": "user", "content": "Can you explain LLMs in plain English?"},
+        ]
+        ```
+    """
+  final_str = ""
+  for msg in messages:
+    if "role" in msg and "content" in msg:
+      role = msg.get("role", "")
+      content = msg.get("content", "")
+      final_str += f"\n\n{role}: {content}"
+  return final_str
+
+
+def format_assistant_message(raw_text: str) -> dict:
+  return {"role": "assistant", "content": raw_text}
+
+
+def load_documents(file_path: str = None, folder_path: str = None,
+                   url: str = None) -> List[Document]:
+  """Loads documents from a local directory or public url or local filename.
+
+  Args:
+      file_path (str): The path to the filename.
+      folder_path (str): The path to the folder.
+      url (str): The url to the file.
+  """
+  #document loaders for filepath
+  if file_path:
+    if file_path.endswith(".pdf"):
+      PDFReader = download_loader("PDFReader")
+      loader = PDFReader()
+      documents = loader.load_data(file=Path(file_path))
+    elif file_path.endswith(".docx"):
+      docReader = download_loader("DocxReader")
+      loader = docReader()
+      documents = loader.load_data(file=Path(file_path))
+    elif file_path.endswith(".txt"):
+      with open(file_path, 'r') as file:
+        text_content = file.read()
+      documents = [Document(text=text_content)]
+    else:
+      raise ValueError("Only .pdf, .docx, and .txt files are supported.")
+
+  #document loaders for folderpath
+  if folder_path:
+    documents = SimpleDirectoryReader(
+        input_dir=Path(folder_path), required_exts=[".pdf", ".docx"]).load_data()
+
+  #document loaders for url
+  if url:
+    response = requests.get(url)
+    if response.status_code != 200:
+      raise ValueError(f"Invalid url {url}.")
+    #for text files
+    try:
+      documents = [Document(text=response.content)]
+    #for pdf files
+    except Exception:
+      documents = []
+      pdf_file = PdfReader(io.BytesIO(response.content))
+      num_pages = len(pdf_file.pages)
+      for page in range(num_pages):
+        page_text = pdf_file.pages[page].extract_text()
+        documents.append(Document(text=page_text))
+    else:
+      raise ValueError(f"Invalid url {url}.")
+
+  return documents
+
+
+def split_document(text: str, chunk_size: int, chunk_overlap: int, **kwargs) -> List[str]:
+  """Splits a document into chunks of text.
+
+  Args:
+      text (str): The text to split.
+      chunk_size (int): The size of each chunk.
+      chunk_overlap (int): The amount of overlap between each chunk.
+      **kwargs: Additional keyword arguments for the SentenceSplitter.
+  """
+  text_parser = SentenceSplitter(chunk_size=chunk_size, chunk_overlap=chunk_overlap, **kwargs)
+  text_chunks = text_parser.split_text(text)
+  return text_chunks

clarifai/schema/search.py

@@ -20,6 +20,9 @@ def get_schema() -> Schema:
             - 'id': Non-empty string
             - 'language': Non-empty string
             - 'value': 0 or 1 integer
+        - 'input_types': List of 'image', 'video', 'text' or 'audio'
+        - 'input_dataset_ids': List of strings
+        - 'input_status_code': Integer
 
         Returns:
             Schema: The schema for rank and filter.

clarifai/urls/helper.py

@@ -58,6 +58,23 @@ class ClarifaiUrlHelper(object):
     return "%s/%s/%s/%s/%s/versions/%s" % (self.auth.ui, user_id, app_id, resource_type,
                                            resource_id, version_id)
 
+  @classmethod
+  def split_clarifai_app_url(cls, url):
+    """
+    clarifai.com uses fully qualified urls to resources.
+    They are in the format of:
+    https://clarifai.com/{user_id}/{app_id}/
+    """
+    url = url.replace("https://", "", 1).replace("http://", "", 1)
+    o = urlparse(url)
+    path = o.path
+    path = path.lstrip("/")
+    parts = path.split("/")
+    if len(parts) != 3:
+      raise ValueError(
+          f"Provided url must have 2 parts after the domain name. The current parts are: {parts}")
+    return tuple(parts[1:])
+
   @classmethod
   def split_clarifai_url(cls, url):
     """

clarifai/versions.py

@@ -1,6 +1,6 @@
 import os
 
-CLIENT_VERSION = "9.11.0"
+CLIENT_VERSION = "10.0.0"
 OS_VER = os.sys.platform
 PYTHON_VERSION = '.'.join(
     map(str, [os.sys.version_info.major, os.sys.version_info.minor, os.sys.version_info.micro]))

{clarifai-9.11.0.dist-info → clarifai-10.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: clarifai
-Version: 9.11.0
+Version: 10.0.0
 Summary: Clarifai Python SDK
 Home-page: https://github.com/Clarifai/clarifai-python
 Author: Clarifai
@@ -20,16 +20,18 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: clarifai-grpc (==9.11.0)
+Requires-Dist: clarifai-grpc (~=10.0.1)
 Requires-Dist: pandas (>=1.3.5)
 Requires-Dist: numpy (>=1.22.0)
 Requires-Dist: tqdm (>=4.65.0)
-Requires-Dist: opencv-python (==4.7.0.68)
-Requires-Dist: tritonclient (==2.34.0)
+Requires-Dist: opencv-python (>=4.7.0.68)
+Requires-Dist: tritonclient (>=2.34.0)
 Requires-Dist: rich (>=13.4.2)
 Requires-Dist: PyYAML (>=6.0.1)
-Requires-Dist: schema (==0.7.5)
+Requires-Dist: schema (>=0.7.5)
 Requires-Dist: Pillow (>=9.5.0)
+Requires-Dist: llama-index (>=0.9.27)
+Requires-Dist: pypdf (>=3.17.4)
 Provides-Extra: all
 Requires-Dist: pycocotools (==2.0.6) ; extra == 'all'
 
@@ -55,7 +57,7 @@ Clarifai Python SDK</a>
 
 This is the official Python client for interacting with our powerful [API](https://docs.clarifai.com). The Clarifai Python SDK offers a comprehensive set of tools to integrate Clarifai's AI platform to leverage computer vision capabilities like classification , detection ,segementation and natural language capabilities like classification , summarisation , generation , Q&A ,etc into your applications. With just a few lines of code, you can leverage cutting-edge artificial intelligence to unlock valuable insights from visual and textual content.
 
-[Website](https://www.clarifai.com/) | [Demo](https://clarifai.com/demo) | [Signup for a Free Account](https://clarifai.com/signup) | [API Docs](https://docs.clarifai.com/) | [Clarifai Community](https://clarifai.com/explore) | [Python SDK Docs](https://docs.clarifai.com/python-sdk/api-reference) | [Examples](https://github.com/Clarifai/examples) | [Colab Notebooks](https://github.com/Clarifai/colab-notebooks) | [Discord](https://discord.gg/XAPE3Vtg)
+[Website](https://www.clarifai.com/) | [Schedule Demo](https://www.clarifai.com/company/schedule-demo) | [Signup for a Free Account](https://clarifai.com/signup) | [API Docs](https://docs.clarifai.com/) | [Clarifai Community](https://clarifai.com/explore) | [Python SDK Docs](https://docs.clarifai.com/python-sdk/api-reference) | [Examples](https://github.com/Clarifai/examples) | [Colab Notebooks](https://github.com/Clarifai/colab-notebooks) | [Discord](https://discord.gg/XAPE3Vtg)
 
 
 ---
@@ -212,6 +214,17 @@ annotations_list = list(annotation_generator)
 all_concepts = list(app.list_concepts())
 ```
 
+#### Input Download
+```python
+#listing inputs
+input_generator = input_obj.list_inputs(page_no=1,per_page=1,input_type='image')
+inputs_list = list(input_generator)
+
+#downloading_inputs
+input_bytes = input_obj.download_inputs(inputs_list)
+with open('demo.jpg','wb') as f:
+  f.write(input_bytes[0])
+```
 
 
 ## :brain: Interacting with Models