gllm-inference-binary 0.5.9b1__cp312-cp312-macosx_10_9_universal2.macosx_13_0_x86_64.whl

gllm_inference/schema/enums.pyi

@@ -0,0 +1,29 @@
+from enum import StrEnum
+
+class AttachmentType(StrEnum):
+    """Defines valid attachment types."""
+    AUDIO = 'audio'
+    DOCUMENT = 'document'
+    IMAGE = 'image'
+    VIDEO = 'video'
+
+class EmitDataType(StrEnum):
+    """Defines valid data types for emitting events."""
+    ACTIVITY = 'activity'
+    CODE = 'code'
+    CODE_START = 'code_start'
+    CODE_END = 'code_end'
+    THINKING = 'thinking'
+    THINKING_START = 'thinking_start'
+    THINKING_END = 'thinking_end'
+
+class MessageRole(StrEnum):
+    """Defines valid message roles."""
+    SYSTEM = 'system'
+    USER = 'user'
+    ASSISTANT = 'assistant'
+
+class TruncateSide(StrEnum):
+    """Enumeration for truncation sides."""
+    RIGHT = 'RIGHT'
+    LEFT = 'LEFT'

gllm_inference/schema/lm_output.pyi

@@ -0,0 +1,36 @@
+from gllm_core.schema import Chunk as Chunk
+from gllm_inference.schema.code_exec_result import CodeExecResult as CodeExecResult
+from gllm_inference.schema.reasoning import Reasoning as Reasoning
+from gllm_inference.schema.token_usage import TokenUsage as TokenUsage
+from gllm_inference.schema.tool_call import ToolCall as ToolCall
+from pydantic import BaseModel
+from typing import Any
+
+class LMOutput(BaseModel):
+    """Defines the output of a language model.
+
+    Attributes:
+        response (str): The text response. Defaults to an empty string.
+        tool_calls (list[ToolCall]): The tool calls, if the language model decides to invoke tools.
+            Defaults to an empty list.
+        structured_output (dict[str, Any] | BaseModel | None): The structured output, if a response schema is defined
+            for the language model. Defaults to None.
+        token_usage (TokenUsage | None): The token usage analytics, if requested. Defaults to None.
+        duration (float | None): The duration of the invocation in seconds, if requested. Defaults to None.
+        finish_details (dict[str, Any]): The details about how the generation finished, if requested.
+            Defaults to an empty dictionary.
+        reasoning (list[Reasoning]): The reasoning, if the language model is configured to output reasoning.
+            Defaults to an empty list.
+        citations (list[Chunk]): The citations, if the language model outputs citations. Defaults to an empty list.
+        code_exec_results (list[CodeExecResult]): The code execution results, if the language model decides to
+            execute code. Defaults to an empty list.
+    """
+    response: str
+    tool_calls: list[ToolCall]
+    structured_output: dict[str, Any] | BaseModel | None
+    token_usage: TokenUsage | None
+    duration: float | None
+    finish_details: dict[str, Any]
+    reasoning: list[Reasoning]
+    citations: list[Chunk]
+    code_exec_results: list[CodeExecResult]

gllm_inference/schema/message.pyi

@@ -0,0 +1,52 @@
+from gllm_inference.schema.enums import MessageRole as MessageRole
+from gllm_inference.schema.type_alias import MessageContent as MessageContent
+from pydantic import BaseModel
+from typing import Any
+
+class Message(BaseModel):
+    """Defines a message schema to be used as inputs for a language model.
+
+    Attributes:
+        role (MessageRole): The role of the message.
+        contents (list[MessageContent]): The contents of the message.
+        metadata (dict[str, Any]): The metadata of the message.
+    """
+    role: MessageRole
+    contents: list[MessageContent]
+    metadata: dict[str, Any]
+    @classmethod
+    def system(cls, contents: MessageContent | list[MessageContent], metadata: dict[str, Any] | None = None) -> Message:
+        """Create a system message.
+
+        Args:
+            contents (MessageContent | list[MessageContent]): The message contents.
+                If a single content is provided, it will be wrapped in a list.
+            metadata (dict[str, Any], optional): Additional metadata for the message. Defaults to None.
+
+        Returns:
+            Message: A new message with SYSTEM role.
+        """
+    @classmethod
+    def user(cls, contents: MessageContent | list[MessageContent], metadata: dict[str, Any] | None = None) -> Message:
+        """Create a user message.
+
+        Args:
+            contents (MessageContent | list[MessageContent]): The message contents.
+                If a single content is provided, it will be wrapped in a list.
+            metadata (dict[str, Any], optional): Additional metadata for the message. Defaults to None.
+
+        Returns:
+            Message: A new message with USER role.
+        """
+    @classmethod
+    def assistant(cls, contents: MessageContent | list[MessageContent], metadata: dict[str, Any] | None = None) -> Message:
+        """Create an assistant message.
+
+        Args:
+            contents (MessageContent | list[MessageContent]): The message contents.
+                If a single content is provided, it will be wrapped in a list.
+            metadata (dict[str, Any], optional): Additional metadata for the message. Defaults to None.
+
+        Returns:
+            Message: A new message with ASSISTANT role.
+        """

gllm_inference/schema/model_id.pyi

@@ -0,0 +1,147 @@
+from enum import StrEnum
+from gllm_inference.utils import validate_string_enum as validate_string_enum
+from pydantic import BaseModel
+
+PROVIDER_SEPARATOR: str
+PATH_SEPARATOR: str
+URL_NAME_REGEX_PATTERN: str
+
+class ModelProvider(StrEnum):
+    """Defines the supported model providers."""
+    ANTHROPIC = 'anthropic'
+    AZURE_OPENAI = 'azure-openai'
+    BEDROCK = 'bedrock'
+    DATASAUR = 'datasaur'
+    GOOGLE = 'google'
+    LANGCHAIN = 'langchain'
+    LITELLM = 'litellm'
+    OPENAI = 'openai'
+    OPENAI_COMPATIBLE = 'openai-compatible'
+    TWELVELABS = 'twelvelabs'
+    VOYAGE = 'voyage'
+    XAI = 'xai'
+
+class ModelId(BaseModel):
+    '''Defines a representation of a valid model id.
+
+    Attributes:
+        provider (ModelProvider): The provider of the model.
+        name (str | None): The name of the model.
+        path (str | None): The path of the model.
+
+    Provider-specific examples:
+        # Using Anthropic
+        ```python
+        model_id = ModelId.from_string("anthropic/claude-3-5-sonnet-latest")
+        ```
+
+        # Using Bedrock
+        ```python
+        model_id = ModelId.from_string("bedrock/us.anthropic.claude-sonnet-4-20250514-v1:0")
+        ```
+
+        # Using Datasaur
+        ```python
+        model_id = ModelId.from_string("datasaur/https://deployment.datasaur.ai/api/deployment/teamId/deploymentId/")
+        ```
+
+        # Using Google
+        ```python
+        model_id = ModelId.from_string("google/gemini-1.5-flash")
+        ```
+
+        # Using OpenAI
+        ```python
+        model_id = ModelId.from_string("openai/gpt-4o-mini")
+        ```
+
+        # Using Azure OpenAI
+        ```python
+        model_id = ModelId.from_string("azure-openai/https://my-resource.openai.azure.com/openai/v1:my-deployment")
+        ```
+
+        # Using OpenAI compatible endpoints (e.g. Groq)
+        ```python
+        model_id = ModelId.from_string("openai-compatible/https://api.groq.com/openai/v1:llama3-8b-8192")
+        ```
+
+        # Using Voyage
+        ```python
+        model_id = ModelId.from_string("voyage/voyage-3.5-lite")
+        ```
+
+        # Using TwelveLabs
+        ```python
+        model_id = ModelId.from_string("twelvelabs/Marengo-retrieval-2.7")
+        ```
+
+        # Using LangChain
+        ```python
+        model_id = ModelId.from_string("langchain/langchain_openai.ChatOpenAI:gpt-4o-mini")
+        ```
+        For the list of supported providers, please refer to the following table:
+        https://python.langchain.com/docs/integrations/chat/#featured-providers
+
+        # Using LiteLLM
+        ```python
+        model_id = ModelId.from_string("litellm/openai/gpt-4o-mini")
+        ```
+        For the list of supported providers, please refer to the following page:
+        https://docs.litellm.ai/docs/providers/
+
+        # Using XAI
+        ```python
+        model_id = ModelId.from_string("xai/grok-4-0709")
+        ```
+        For the list of supported models, please refer to the following page:
+        https://docs.x.ai/docs/models
+
+    Custom model name validation example:
+        ```python
+        validation_map = {
+            ModelProvider.ANTHROPIC: {"claude-3-5-sonnet-latest"},
+            ModelProvider.GOOGLE: {"gemini-1.5-flash", "gemini-1.5-pro"},
+            ModelProvider.OPENAI: {"gpt-4o", "gpt-4o-mini"},
+        }
+
+        model_id = ModelId.from_string("...", validation_map)
+        ```
+    '''
+    provider: ModelProvider
+    name: str | None
+    path: str | None
+    @classmethod
+    def from_string(cls, model_id: str, validation_map: dict[str, set[str]] | None = None) -> ModelId:
+        """Parse a model id string into a ModelId object.
+
+        Args:
+            model_id (str): The model id to parse. Must be in the the following format:
+                1. For `azure-openai` provider: `azure-openai/azure-endpoint:azure-deployment`.
+                2. For `openai-compatible` provider: `openai-compatible/base-url:model-name`.
+                3. For `langchain` provider: `langchain/<package>.<class>:model-name`.
+                4. For `litellm` provider: `litellm/provider/model-name`.
+                5. For `datasaur` provider: `datasaur/base-url`.
+                6. For other providers: `provider/model-name`.
+            validation_map (dict[str, set[str]] | None, optional): An optional dictionary that maps provider names to
+                sets of valid model names. For the defined model providers, the model names will be validated against
+                the set of valid model names. For the undefined model providers, the model name will not be validated.
+                Defaults to None.
+
+        Returns:
+            ModelId: The parsed ModelId object.
+
+        Raises:
+            ValueError: If the provided model id is invalid or if the model name is not valid for the provider.
+        """
+    def to_string(self) -> str:
+        """Convert the ModelId object to a string.
+
+        Returns:
+            str: The string representation of the ModelId object. The format is as follows:
+                1. For `azure-openai` provider: `azure-openai/azure-endpoint:azure-deployment`.
+                2. For `openai-compatible` provider: `openai-compatible/base-url:model-name`.
+                3. For `langchain` provider: `langchain/<package>.<class>:model-name`.
+                4. For `litellm` provider: `litellm/provider/model-name`.
+                5. For `datasaur` provider: `datasaur/base-url`.
+                6. For other providers: `provider/model-name`.
+        """

gllm_inference/schema/reasoning.pyi

@@ -0,0 +1,15 @@
+from pydantic import BaseModel
+
+class Reasoning(BaseModel):
+    """Defines a reasoning output when a language model is configured to use reasoning.
+
+    Attributes:
+        id (str): The ID of the reasoning output. Defaults to an empty string.
+        reasoning (str): The reasoning text. Defaults to an empty string.
+        type (str): The type of the reasoning output. Defaults to an empty string.
+        data (str): The additional data of the reasoning output. Defaults to an empty string.
+    """
+    id: str
+    reasoning: str
+    type: str
+    data: str

gllm_inference/schema/token_usage.pyi

@@ -0,0 +1,75 @@
+from pydantic import BaseModel
+
+class InputTokenDetails(BaseModel):
+    """Defines the input token details schema.
+
+    Attributes:
+        cached_tokens (int): The number of cached tokens. Defaults to 0.
+        uncached_tokens (int): The number of uncached tokens. Defaults to 0.
+    """
+    cached_tokens: int
+    uncached_tokens: int
+    def __add__(self, other: InputTokenDetails) -> InputTokenDetails:
+        """Add two InputTokenDetails objects together.
+
+        Args:
+            other (InputTokenDetails): The other InputTokenDetails object to add.
+
+        Returns:
+            InputTokenDetails: A new InputTokenDetails object with summed values.
+        """
+
+class OutputTokenDetails(BaseModel):
+    """Defines the output token details schema.
+
+    Attributes:
+        reasoning_tokens (int): The number of reasoning tokens. Defaults to 0.
+        response_tokens (int): The number of response tokens. Defaults to 0.
+    """
+    reasoning_tokens: int
+    response_tokens: int
+    def __add__(self, other: OutputTokenDetails) -> OutputTokenDetails:
+        """Add two OutputTokenDetails objects together.
+
+        Args:
+            other (OutputTokenDetails): The other OutputTokenDetails object to add.
+
+        Returns:
+            OutputTokenDetails: A new OutputTokenDetails object with summed values.
+        """
+
+class TokenUsage(BaseModel):
+    """Defines the token usage data structure of a language model.
+
+    Attributes:
+        input_tokens (int): The number of input tokens. Defaults to 0.
+        output_tokens (int): The number of output tokens. Defaults to 0.
+        input_token_details (InputTokenDetails | None): The details of the input tokens. Defaults to None.
+        output_token_details (OutputTokenDetails | None): The details of the output tokens. Defaults to None.
+    """
+    input_tokens: int
+    output_tokens: int
+    input_token_details: InputTokenDetails | None
+    output_token_details: OutputTokenDetails | None
+    @classmethod
+    def from_token_details(cls, input_tokens: int | None = None, output_tokens: int | None = None, cached_tokens: int | None = None, reasoning_tokens: int | None = None) -> TokenUsage:
+        """Creates a TokenUsage from token details.
+
+        Args:
+            input_tokens (int | None): The number of input tokens. Defaults to None.
+            output_tokens (int | None): The number of output tokens. Defaults to None.
+            cached_tokens (int | None): The number of cached tokens. Defaults to None.
+            reasoning_tokens (int | None): The number of reasoning tokens. Defaults to None.
+
+        Returns:
+            TokenUsage: The instantiated TokenUsage.
+        """
+    def __add__(self, other: TokenUsage) -> TokenUsage:
+        """Add two TokenUsage objects together.
+
+        Args:
+            other (TokenUsage): The other TokenUsage object to add.
+
+        Returns:
+            TokenUsage: A new TokenUsage object with summed values.
+        """

gllm_inference/schema/tool_call.pyi

@@ -0,0 +1,14 @@
+from pydantic import BaseModel
+from typing import Any
+
+class ToolCall(BaseModel):
+    """Defines a tool call request when a language model decides to invoke a tool.
+
+    Attributes:
+        id (str): The ID of the tool call.
+        name (str): The name of the tool.
+        args (dict[str, Any]): The arguments of the tool call.
+    """
+    id: str
+    name: str
+    args: dict[str, Any]

gllm_inference/schema/tool_result.pyi

@@ -0,0 +1,11 @@
+from pydantic import BaseModel
+
+class ToolResult(BaseModel):
+    """Defines a tool result to be sent back to the language model.
+
+    Attributes:
+        id (str): The ID of the tool call.
+        output (str): The output of the tool call.
+    """
+    id: str
+    output: str

gllm_inference/schema/type_alias.pyi

@@ -0,0 +1,11 @@
+from gllm_inference.schema.attachment import Attachment as Attachment
+from gllm_inference.schema.reasoning import Reasoning as Reasoning
+from gllm_inference.schema.tool_call import ToolCall as ToolCall
+from gllm_inference.schema.tool_result import ToolResult as ToolResult
+from pydantic import BaseModel
+from typing import Any
+
+ResponseSchema = dict[str, Any] | type[BaseModel]
+MessageContent = str | Attachment | ToolCall | ToolResult | Reasoning
+EMContent = str | Attachment | tuple[str | Attachment, ...]
+Vector = list[float]

gllm_inference/utils/__init__.pyi

@@ -0,0 +1,5 @@
+from gllm_inference.utils.io_utils import base64_to_bytes as base64_to_bytes
+from gllm_inference.utils.langchain import load_langchain_model as load_langchain_model, parse_model_data as parse_model_data
+from gllm_inference.utils.validation import validate_string_enum as validate_string_enum
+
+__all__ = ['base64_to_bytes', 'load_langchain_model', 'parse_model_data', 'validate_string_enum']

gllm_inference/utils/io_utils.pyi

@@ -0,0 +1,26 @@
+from _typeshed import Incomplete
+
+logger: Incomplete
+DEFAULT_BASE64_ALLOWED_MIMETYPES: Incomplete
+
+def base64_to_bytes(value: str, *, allowed_mimetypes: tuple[str, ...] | None = ...) -> str | bytes:
+    '''Decode a base64 string to bytes based on allowed MIME type.
+
+    The conversion steps are as follows:
+        1. The function first attempts to decode the given string from base64.
+        2. If decoding succeeds, it checks the MIME type of the decoded content.
+        3. When the MIME type matches one of the allowed patterns (e.g., ``"image/*"``),
+            the raw bytes are returned. Otherwise, the original string is returned unchanged.
+
+    Args:
+        value (str): Input data to decode.
+        allowed_mimetypes (tuple[str, ...], optional): MIME type prefixes that are allowed
+            to be decoded into bytes. Defaults to ("image/*", "audio/*", "video/*").
+
+    Returns:
+        str | bytes: Base64-encoded string or raw bytes if MIME type is allowed;
+            otherwise returns original string.
+
+    Raises:
+        ValueError: If the input is not a string.
+    '''

gllm_inference/utils/langchain.pyi

@@ -0,0 +1,30 @@
+from _typeshed import Incomplete
+from langchain_core.embeddings import Embeddings as Embeddings
+from langchain_core.language_models import BaseChatModel as BaseChatModel
+from typing import Any
+
+MODEL_NAME_KEYS: Incomplete
+
+def load_langchain_model(model_class_path: str, model_name: str, model_kwargs: dict[str, Any]) -> BaseChatModel | Embeddings:
+    '''Loads the LangChain\'s model instance.
+
+    Args:
+        model_class_path (str): The path to the LangChain\'s class, e.g. "langchain_openai.ChatOpenAI".
+        model_name (str): The model name.
+        model_kwargs (dict[str, Any]): The additional keyword arguments.
+
+    Returns:
+        BaseChatModel | Embeddings: The LangChain\'s model instance.
+    '''
+def parse_model_data(model: BaseChatModel | Embeddings) -> dict[str, str]:
+    """Parses the model data from LangChain's BaseChatModel or Embeddings instance.
+
+    Args:
+        model (BaseChatModel | Embeddings): The LangChain's BaseChatModel or Embeddings instance.
+
+    Returns:
+        dict[str, str]: The dictionary containing the model name and path.
+
+    Raises:
+        ValueError: If the model name is not found in the model data.
+    """

gllm_inference/utils/validation.pyi

@@ -0,0 +1,12 @@
+from enum import StrEnum
+
+def validate_string_enum(enum_type: type[StrEnum], value: str) -> None:
+    """Validates that the provided value is a valid string enum value.
+
+    Args:
+        enum_type (type[StrEnum]): The type of the string enum.
+        value (str): The value to validate.
+
+    Raises:
+        ValueError: If the provided value is not a valid string enum value.
+    """

gllm_inference.build/.gitignore

@@ -0,0 +1 @@
+*

gllm_inference.pyi

@@ -0,0 +1,123 @@
+# This file was generated by Nuitka
+
+# Stubs included by default
+
+
+__name__ = ...
+
+
+
+# Modules used internally, to allow implicit dependencies to be seen:
+import os
+import typing
+import gllm_core
+import gllm_core.utils
+import gllm_inference.em_invoker.AzureOpenAIEMInvoker
+import gllm_inference.em_invoker.BedrockEMInvoker
+import gllm_inference.em_invoker.GoogleEMInvoker
+import gllm_inference.em_invoker.LangChainEMInvoker
+import gllm_inference.em_invoker.OpenAICompatibleEMInvoker
+import gllm_inference.em_invoker.OpenAIEMInvoker
+import gllm_inference.em_invoker.TwelveLabsEMInvoker
+import gllm_inference.em_invoker.VoyageEMInvoker
+import gllm_inference.lm_invoker.AnthropicLMInvoker
+import gllm_inference.lm_invoker.AzureOpenAILMInvoker
+import gllm_inference.lm_invoker.BedrockLMInvoker
+import gllm_inference.lm_invoker.DatasaurLMInvoker
+import gllm_inference.lm_invoker.GoogleLMInvoker
+import gllm_inference.lm_invoker.LangChainLMInvoker
+import gllm_inference.lm_invoker.LiteLLMLMInvoker
+import gllm_inference.lm_invoker.OpenAICompatibleLMInvoker
+import gllm_inference.lm_invoker.OpenAILMInvoker
+import gllm_inference.lm_invoker.XAILMInvoker
+import gllm_inference.prompt_builder.PromptBuilder
+import gllm_inference.output_parser.JSONOutputParser
+import json
+import abc
+import pandas
+import pydantic
+import re
+import gllm_core.utils.retry
+import gllm_inference.request_processor.LMRequestProcessor
+import gllm_core.utils.imports
+import gllm_inference.schema.ModelId
+import gllm_inference.schema.ModelProvider
+import gllm_inference.schema.TruncationConfig
+import openai
+import asyncio
+import enum
+import gllm_inference.exceptions.BaseInvokerError
+import gllm_inference.exceptions.convert_http_status_to_base_invoker_error
+import gllm_inference.schema.Vector
+import aioboto3
+import asyncio.CancelledError
+import gllm_inference.exceptions.convert_to_base_invoker_error
+import gllm_inference.schema.Attachment
+import gllm_inference.schema.AttachmentType
+import gllm_inference.schema.EMContent
+import gllm_inference.schema.TruncateSide
+import google
+import google.auth
+import google.genai
+import google.genai.types
+import concurrent
+import concurrent.futures
+import concurrent.futures.ThreadPoolExecutor
+import langchain_core
+import langchain_core.embeddings
+import gllm_inference.exceptions.InvokerRuntimeError
+import gllm_inference.exceptions.build_debug_info
+import gllm_inference.utils.load_langchain_model
+import gllm_inference.utils.parse_model_data
+import io
+import httpx
+import twelvelabs
+import base64
+import sys
+import voyageai
+import voyageai.client_async
+import http
+import http.HTTPStatus
+import gllm_core.constants
+import gllm_core.event
+import gllm_core.schema
+import gllm_core.schema.tool
+import langchain_core.tools
+import gllm_inference.schema.EmitDataType
+import gllm_inference.schema.LMOutput
+import gllm_inference.schema.Message
+import gllm_inference.schema.Reasoning
+import gllm_inference.schema.ResponseSchema
+import gllm_inference.schema.TokenUsage
+import gllm_inference.schema.ToolCall
+import gllm_inference.schema.ToolResult
+import anthropic
+import gllm_inference.schema.MessageRole
+import langchain_core.language_models
+import langchain_core.messages
+import gllm_inference.exceptions._get_exception_key
+import litellm
+import inspect
+import time
+import jsonschema
+import gllm_inference.schema.MessageContent
+import gllm_inference.utils.validate_string_enum
+import gllm_inference.schema.CodeExecResult
+import xai_sdk
+import xai_sdk.chat
+import xai_sdk.search
+import xai_sdk.proto
+import xai_sdk.proto.v6
+import xai_sdk.proto.v6.chat_pb2
+import transformers
+import gllm_inference.prompt_formatter.HuggingFacePromptFormatter
+import gllm_core.utils.logger_manager
+import mimetypes
+import uuid
+import pathlib
+import filetype
+import magic
+import requests
+import binascii
+import fnmatch
+import importlib

gllm_inference_binary-0.5.9b1.dist-info/METADATA

@@ -0,0 +1,71 @@
+Metadata-Version: 2.2
+Name: gllm-inference-binary
+Version: 0.5.9b1
+Summary: A library containing components related to model inferences in Gen AI applications.
+Author-email: Henry Wicaksono <henry.wicaksono@gdplabs.id>, Resti Febrina <resti.febrina@gdplabs.id>
+Description-Content-Type: text/markdown
+
+# GLLM Inference
+
+## Description
+
+A library containing components related to model inferences in Gen AI applications.
+
+## Installation
+
+### Prerequisites
+- Python 3.11+ - [Install here](https://www.python.org/downloads/)
+- Pip (if using Pip) - [Install here](https://pip.pypa.io/en/stable/installation/)
+- Poetry 1.8.1+ (if using Poetry) - [Install here](https://python-poetry.org/docs/#installation)
+- Git (if using Git) - [Install here](https://git-scm.com/downloads)
+- For git installation:
+  - Access to the [GDP Labs SDK github repository](https://github.com/GDP-ADMIN/gen-ai-internal)
+
+### 1. Installation from Artifact Registry
+Choose one of the following methods to install the package:
+
+#### Using pip
+```bash
+pip install gllm-inference-binary
+```
+
+#### Using Poetry
+```bash
+poetry add gllm-inference-binary
+```
+
+### 2. Development Installation (Git)
+For development purposes, you can install directly from the Git repository:
+```bash
+poetry add "git+ssh://git@github.com/GDP-ADMIN/gen-ai-internal.git#subdirectory=libs/gllm-inference"
+```
+
+Available extras:
+- `anthropic`: Install Anthropic models dependencies
+- `google-genai`: Install Google Generative AI models dependencies
+- `google-vertexai`: Install Google Vertex AI models dependencies
+- `huggingface`: Install HuggingFace models dependencies
+- `openai`: Install OpenAI models dependencies
+- `twelvelabs`: Install TwelveLabs models dependencies
+
+## Managing Dependencies
+1. Go to root folder of `gllm-inference` module, e.g. `cd libs/gllm-inference`.
+2. Run `poetry shell` to create a virtual environment.
+3. Run `poetry lock` to create a lock file if you haven't done it yet.
+4. Run `poetry install` to install the `gllm-inference` requirements for the first time.
+5. Run `poetry update` if you update any dependency module version at `pyproject.toml`.
+
+## Contributing
+Please refer to this [Python Style Guide](https://docs.google.com/document/d/1uRggCrHnVfDPBnG641FyQBwUwLoFw0kTzNqRm92vUwM/edit?usp=sharing)
+to get information about code style, documentation standard, and SCA that you need to use when contributing to this project
+
+1. Activate `pre-commit` hooks using `pre-commit install`
+2. Run `poetry shell` to create a virtual environment.
+3. Run `poetry lock` to create a lock file if you haven't done it yet.
+4. Run `poetry install` to install the `gllm-inference` requirements for the first time.
+5. Run `which python` to get the path to be referenced at Visual Studio Code interpreter path (`Ctrl`+`Shift`+`P` or `Cmd`+`Shift`+`P`)
+6. Try running the unit test to see if it's working:
+```bash
+poetry run pytest -s tests/unit_tests/
+```
+