h2oGPTe

https://h2oai.github.io/h2ogpte/
Admin
h2oGPTe is a RAG-based generative AI platform that enables organizations to contextualize chat with...
Tokens:340,288
Snippets:1,673
Trust Score:8.3
Update:3 months ago
Show doc for...
Tokens:
Raw
### Initialize and Convert GlobalConfigurationItem

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/GlobalConfigurationItem.md.txt

Demonstrates creating an instance from JSON, converting to a dictionary, and re-instantiating from that dictionary.

```python
from h2ogpte.rest_async.models.global_configuration_item import GlobalConfigurationItem

# TODO update the JSON string below
json = "{}"
# create an instance of GlobalConfigurationItem from a JSON string
global_configuration_item_instance = GlobalConfigurationItem.from_json(json)
# print the JSON string representation of the object
print(GlobalConfigurationItem.to_json())

# convert the object into a dict
global_configuration_item_dict = global_configuration_item_instance.to_dict()
# create an instance of GlobalConfigurationItem from a dict
global_configuration_item_from_dict = GlobalConfigurationItem.from_dict(global_configuration_item_dict)
```

--------------------------------

### GET /embedding-models/default

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/ModelsApi.md.txt

Gets default embedding model.

```APIDOC
## GET /embedding-models/default

### Description
Gets default embedding model.

### Method
GET

### Endpoint
/embedding-models/default
```

--------------------------------

### GET /models/model-to-vision-model-mapping

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/ModelsApi.md.txt

Get mapping of llm to its vision-model when ["auto"] is passed as visible-vision-models.

```APIDOC
## GET /models/model-to-vision-model-mapping

### Description
Get mapping of llm to its vision-model when ["auto"] is passed as visible-vision-models.

### Method
GET

### Endpoint
/models/model-to-vision-model-mapping
```

--------------------------------

### Initialize and use h2oGPTe Async Client

Source: https://h2oai.github.io/h2ogpte/_sources/async_api.rst.txt

Demonstrates connecting to the service, creating a collection, uploading files, and querying a chat session asynchronously.

```python
from pathlib import Path
from h2ogpte import H2OGPTEAsync

client = H2OGPTEAsync(
    address="https://h2ogpte.genai.h2o.ai",
    api_key=API_KEY,
)

# Create Collection
collection_id = await client.create_collection(
    name="My first h2oGPTe collection",
    description="PDF -> text -> summary",
)

file_path = Path("...path to document(s)...")
with open(file_path.resolve(), "rb") as f:
    upload_id = await client.upload(file_path.name, f)

# Converting the input into chunked text and embeddings...
await client.ingest_uploads(collection_id, [upload_id])

# Chat with LLM
chat_session_id = await client.create_chat_session(collection_id)
async with client.connect(chat_session_id) as session:
    # Simple Question for Document Collection
    answer = await session.query(
        "What was net revenue?",
    )
    print(answer.content)
```

--------------------------------

### Initialize and Convert QAFeedback Model

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/QAFeedback.md.txt

Demonstrates how to instantiate the QAFeedback model from JSON or a dictionary, and how to serialize it back to those formats.

```python
from h2ogpte.rest_async.models.qa_feedback import QAFeedback

# TODO update the JSON string below
json = "{}"
# create an instance of QAFeedback from a JSON string
qa_feedback_instance = QAFeedback.from_json(json)
# print the JSON string representation of the object
print(QAFeedback.to_json())

# convert the object into a dict
qa_feedback_dict = qa_feedback_instance.to_dict()
# create an instance of QAFeedback from a dict
qa_feedback_from_dict = QAFeedback.from_dict(qa_feedback_dict)
```

--------------------------------

### GET /models/model-to-reasoning-model-mapping

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/ModelsApi.md.txt

Get mapping of llm to its reasoning-model when ["auto"] is passed as visible-reasoning-models.

```APIDOC
## GET /models/model-to-reasoning-model-mapping

### Description
Get mapping of llm to its reasoning-model when ["auto"] is passed as visible-reasoning-models.

### Method
GET

### Endpoint
/models/model-to-reasoning-model-mapping
```

--------------------------------

### Install h2oGPTe via pip

Source: https://h2oai.github.io/h2ogpte/_sources/installation.rst.txt

Use this command to install the h2oGPTe Python client from the Python Package Index.

```bash
pip install h2ogpte
```

--------------------------------

### Initialize and Convert AgentServerFile

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/AgentServerFile.md.txt

Demonstrates creating an AgentServerFile instance from JSON or a dictionary and converting it back to these formats.

```python
from h2ogpte.rest_async.models.agent_server_file import AgentServerFile

# TODO update the JSON string below
json = "{}"
# create an instance of AgentServerFile from a JSON string
agent_server_file_instance = AgentServerFile.from_json(json)
# print the JSON string representation of the object
print(AgentServerFile.to_json())

# convert the object into a dict
agent_server_file_dict = agent_server_file_instance.to_dict()
# create an instance of AgentServerFile from a dict
agent_server_file_from_dict = AgentServerFile.from_dict(agent_server_file_dict)
```

--------------------------------

### GET /chats/{session_id}/agent_server_directories/{directory_name}/stats

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/ChatApi.md.txt

Gets statistics for an agent server directory within a chat session.

```APIDOC
## GET /chats/{session_id}/agent_server_directories/{directory_name}/stats

### Description
Gets stats of a agent server directory.

### Method
GET

### Endpoint
/chats/{session_id}/agent_server_directories/{directory_name}/stats

### Parameters
#### Path Parameters
- **session_id** (string) - Required - The ID of the chat session.
- **directory_name** (string) - Required - The name of the directory.
```

--------------------------------

### Initialize and Convert AgentServerDirectoryStats

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/AgentServerDirectoryStats.md.txt

Demonstrates how to instantiate the model from JSON or a dictionary and convert it back to those formats.

```python
from h2ogpte.rest_async.models.agent_server_directory_stats import AgentServerDirectoryStats

# TODO update the JSON string below
json = "{}"
# create an instance of AgentServerDirectoryStats from a JSON string
agent_server_directory_stats_instance = AgentServerDirectoryStats.from_json(json)
# print the JSON string representation of the object
print(AgentServerDirectoryStats.to_json())

# convert the object into a dict
agent_server_directory_stats_dict = agent_server_directory_stats_instance.to_dict()
# create an instance of AgentServerDirectoryStats from a dict
agent_server_directory_stats_from_dict = AgentServerDirectoryStats.from_dict(agent_server_directory_stats_dict)
```

--------------------------------

### Initialize and Convert UsageStatsPerModelAndUser in Python

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/UsageStatsPerModelAndUser.md.txt

Demonstrates how to create an instance from JSON or a dictionary and convert it back to those formats.

```python
from h2ogpte.rest_async.models.usage_stats_per_model_and_user import UsageStatsPerModelAndUser

# TODO update the JSON string below
json = "{}"
# create an instance of UsageStatsPerModelAndUser from a JSON string
usage_stats_per_model_and_user_instance = UsageStatsPerModelAndUser.from_json(json)
# print the JSON string representation of the object
print(UsageStatsPerModelAndUser.to_json())

# convert the object into a dict
usage_stats_per_model_and_user_dict = usage_stats_per_model_and_user_instance.to_dict()
# create an instance of UsageStatsPerModelAndUser from a dict
usage_stats_per_model_and_user_from_dict = UsageStatsPerModelAndUser.from_dict(usage_stats_per_model_and_user_dict)
```

--------------------------------

### GET /tags

Source: https://h2oai.github.io/h2ogpte/rest_async/TagsApi.html

List tags.

```APIDOC
## GET /tags

### Description
List tags.

### Method
GET

### Endpoint
/tags
```

--------------------------------

### GET /collections

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/CollectionsApi.md.txt

List collections.

```APIDOC
## GET /collections

### Description
List collections.

### Method
GET

### Endpoint
/collections
```

--------------------------------

### Initialize and Convert AgentServerDirectoryFileStats

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/AgentServerDirectoryFileStats.md.txt

Demonstrates how to instantiate the model from JSON or a dictionary and convert it back to those formats.

```python
from h2ogpte.rest_async.models.agent_server_directory_file_stats import AgentServerDirectoryFileStats

# TODO update the JSON string below
json = "{}"
# create an instance of AgentServerDirectoryFileStats from a JSON string
agent_server_directory_file_stats_instance = AgentServerDirectoryFileStats.from_json(json)
# print the JSON string representation of the object
print(AgentServerDirectoryFileStats.to_json())

# convert the object into a dict
agent_server_directory_file_stats_dict = agent_server_directory_file_stats_instance.to_dict()
# create an instance of AgentServerDirectoryFileStats from a dict
agent_server_directory_file_stats_from_dict = AgentServerDirectoryFileStats.from_dict(agent_server_directory_file_stats_dict)
```

--------------------------------

### Create a new prompt template

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/PromptTemplatesApi.md.txt

Demonstrates how to initialize the API client with bearer authentication and create a new prompt template.

```python
import h2ogpte.rest_async
from h2ogpte.rest_async.models.prompt_template import PromptTemplate
from h2ogpte.rest_async.models.prompt_template_create_request import PromptTemplateCreateRequest
from h2ogpte.rest_async.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to https://h2ogpte.genai.h2o.ai/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = h2ogpte.rest_async.Configuration(
    host = "https://h2ogpte.genai.h2o.ai/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure Bearer authorization: bearerAuth
configuration = h2ogpte.rest_async.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
async with h2ogpte.rest_async.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = h2ogpte.rest_async.PromptTemplatesApi(api_client)
    prompt_template_create_request = h2ogpte.rest_async.PromptTemplateCreateRequest() # PromptTemplateCreateRequest | 

    try:
        # Creates a new prompt template.
        api_response = await api_instance.create_prompt_template(prompt_template_create_request)
        print("The response of PromptTemplatesApi->create_prompt_template:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PromptTemplatesApi->create_prompt_template: %s\n" % e)
```

--------------------------------

### GET /documents

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/DocumentsApi.md.txt

List documents.

```APIDOC
## GET /documents

### Description
List documents.

### Method
GET

### Endpoint
/documents
```

--------------------------------

### GET /collections/count

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/CollectionsApi.md.txt

Counts a number of collections.

```APIDOC
## GET /collections/count

### Description
Counts a number of collections.

### Method
GET

### Endpoint
/collections/count
```

--------------------------------

### Instantiate and Serialize PromptTemplate in Python

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/PromptTemplate.md.txt

Demonstrates how to create a PromptTemplate instance from JSON or a dictionary and how to serialize it back to JSON or a dictionary.

```python
from h2ogpte.rest_async.models.prompt_template import PromptTemplate

# TODO update the JSON string below
json = "{}"
# create an instance of PromptTemplate from a JSON string
prompt_template_instance = PromptTemplate.from_json(json)
# print the JSON string representation of the object
print(PromptTemplate.to_json())

# convert the object into a dict
prompt_template_dict = prompt_template_instance.to_dict()
# create an instance of PromptTemplate from a dict
prompt_template_from_dict = PromptTemplate.from_dict(prompt_template_dict)
```

--------------------------------

### Initialize and Convert SuggestedQuestion

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/SuggestedQuestion.md.txt

Demonstrates creating a SuggestedQuestion instance from JSON, converting it to a dictionary, and back again.

```python
from h2ogpte.rest_async.models.suggested_question import SuggestedQuestion

# TODO update the JSON string below
json = "{}"
# create an instance of SuggestedQuestion from a JSON string
suggested_question_instance = SuggestedQuestion.from_json(json)
# print the JSON string representation of the object
print(SuggestedQuestion.to_json())

# convert the object into a dict
suggested_question_dict = suggested_question_instance.to_dict()
# create an instance of SuggestedQuestion from a dict
suggested_question_from_dict = SuggestedQuestion.from_dict(suggested_question_dict)
```

--------------------------------

### GET /permissions

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/PermissionsApi.md.txt

Returns system permissions.

```APIDOC
## GET /permissions

### Description
Returns system permissions.

### Method
GET

### Endpoint
/permissions
```

--------------------------------

### GET /chats

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/ChatApi.md.txt

Lists all chat sessions.

```APIDOC
## GET /chats

### Description
List chat sessions.

### Method
GET

### Endpoint
/chats
```

--------------------------------

### Initialize and Serialize CollectionSettings in Python

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/CollectionSettings.md.txt

Demonstrates how to instantiate the CollectionSettings model from JSON or a dictionary and convert it back to those formats.

```python
from h2ogpte.rest_async.models.collection_settings import CollectionSettings

# TODO update the JSON string below
json = "{}"
# create an instance of CollectionSettings from a JSON string
collection_settings_instance = CollectionSettings.from_json(json)
# print the JSON string representation of the object
print(CollectionSettings.to_json())

# convert the object into a dict
collection_settings_dict = collection_settings_instance.to_dict()
# create an instance of CollectionSettings from a dict
collection_settings_from_dict = CollectionSettings.from_dict(collection_settings_dict)
```

--------------------------------

### Initialize and Serialize AgentKey in Python

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/AgentKey.md.txt

Demonstrates how to create an AgentKey instance from JSON or a dictionary and convert it back to those formats.

```python
from h2ogpte.rest_async.models.agent_key import AgentKey

# TODO update the JSON string below
json = "{}"
# create an instance of AgentKey from a JSON string
agent_key_instance = AgentKey.from_json(json)
# print the JSON string representation of the object
print(AgentKey.to_json())

# convert the object into a dict
agent_key_dict = agent_key_instance.to_dict()
# create an instance of AgentKey from a dict
agent_key_from_dict = AgentKey.from_dict(agent_key_dict)
```

--------------------------------

### GET /documents/count

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/DocumentsApi.md.txt

Counts a number of documents.

```APIDOC
## GET /documents/count

### Description
Counts a number of documents.

### Method
GET

### Endpoint
/documents/count
```

--------------------------------

### Create a role using Python

Source: https://h2oai.github.io/h2ogpte/_sources/rest_sync/PermissionsApi.md.txt

Demonstrates how to initialize the API client with Bearer authentication and invoke the create_role method.

```python
import h2ogpte.rest_sync
from h2ogpte.rest_sync.models.role_create_request import RoleCreateRequest
from h2ogpte.rest_sync.models.role_info import RoleInfo
from h2ogpte.rest_sync.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to https://h2ogpte.genai.h2o.ai/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = h2ogpte.rest_sync.Configuration(
    host = "https://h2ogpte.genai.h2o.ai/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure Bearer authorization: bearerAuth
configuration = h2ogpte.rest_sync.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with h2ogpte.rest_sync.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = h2ogpte.rest_sync.PermissionsApi(api_client)
    role_create_request = h2ogpte.rest_sync.RoleCreateRequest() # RoleCreateRequest | 

    try:
        # Creates a role.
        api_response = api_instance.create_role(role_create_request)
        print("The response of PermissionsApi->create_role:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PermissionsApi->create_role: %s\n" % e)
```

--------------------------------

### GET /prompt-templates

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/PromptTemplatesApi.md.txt

List prompt templates.

```APIDOC
## GET /prompt-templates

### Description
List prompt templates.

### Method
GET

### Endpoint
/prompt-templates
```

--------------------------------

### GET /agents/keys

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/AgentsApi.md.txt

Lists agent keys.

```APIDOC
## GET /agents/keys

### Description
Lists agent keys.

### Method
GET

### Endpoint
/agents/keys
```

--------------------------------

### List current user configurations with Python

Source: https://h2oai.github.io/h2ogpte/_sources/rest_sync/ConfigurationsApi.md.txt

Demonstrates how to initialize the API client with Bearer authentication and call the list_current_user_configurations method.

```python
import h2ogpte.rest_sync
from h2ogpte.rest_sync.models.user_configuration_item import UserConfigurationItem
from h2ogpte.rest_sync.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to https://h2ogpte.genai.h2o.ai/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = h2ogpte.rest_sync.Configuration(
    host = "https://h2ogpte.genai.h2o.ai/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure Bearer authorization: bearerAuth
configuration = h2ogpte.rest_sync.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
with h2ogpte.rest_sync.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = h2ogpte.rest_sync.ConfigurationsApi(api_client)

    try:
        # Gets configurations for current users.
        api_response = api_instance.list_current_user_configurations()
        print("The response of ConfigurationsApi->list_current_user_configurations:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ConfigurationsApi->list_current_user_configurations: %s\n" % e)
```

--------------------------------

### Initialize and Convert IngestFromFileSystemBody

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/IngestFromFileSystemBody.md.txt

Demonstrates creating an instance from JSON or a dictionary and converting it back to those formats.

```python
from h2ogpte.rest_async.models.ingest_from_file_system_body import IngestFromFileSystemBody

# TODO update the JSON string below
json = "{}"
# create an instance of IngestFromFileSystemBody from a JSON string
ingest_from_file_system_body_instance = IngestFromFileSystemBody.from_json(json)
# print the JSON string representation of the object
print(IngestFromFileSystemBody.to_json())

# convert the object into a dict
ingest_from_file_system_body_dict = ingest_from_file_system_body_instance.to_dict()
# create an instance of IngestFromFileSystemBody from a dict
ingest_from_file_system_body_from_dict = IngestFromFileSystemBody.from_dict(ingest_from_file_system_body_dict)
```

--------------------------------

### GET /extractors

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/ExtractorsApi.md.txt

Lists all available extractors.

```APIDOC
## GET /extractors

### Description
Lists all available extractors.

### Method
GET

### Endpoint
/extractors
```

--------------------------------

### List system permissions using Python

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/PermissionsApi.md.txt

Demonstrates how to initialize the API client with Bearer authentication and call the list_permissions endpoint.

```python
import h2ogpte.rest_async
from h2ogpte.rest_async.models.user_permission import UserPermission
from h2ogpte.rest_async.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to https://h2ogpte.genai.h2o.ai/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = h2ogpte.rest_async.Configuration(
    host = "https://h2ogpte.genai.h2o.ai/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure Bearer authorization: bearerAuth
configuration = h2ogpte.rest_async.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
async with h2ogpte.rest_async.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = h2ogpte.rest_async.PermissionsApi(api_client)
    group_names = ['group_names_example'] # List[str] | If set, the output permissions will be related only to given groups. (optional)
    role_names = ['role_names_example'] # List[str] | If set, the output permissions will be related only to given roles. (optional)

    try:
        # Returns system permissions.
        api_response = await api_instance.list_permissions(group_names=group_names, role_names=role_names)
        print("The response of PermissionsApi->list_permissions:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling PermissionsApi->list_permissions: %s\n" % e)
```

--------------------------------

### _get_user_configurations()

Source: https://h2oai.github.io/h2ogpte/h2ogpte.html

Gets the user configurations for the current user.

```APIDOC
## _get_user_configurations()

### Description
Gets the user configurations for the current user.

### Returns
- **List[ConfigItem]** - List of user configurations.
```

--------------------------------

### Initialize and Serialize UserConfigurationItem

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/UserConfigurationItem.md.txt

Demonstrates creating a UserConfigurationItem instance from JSON and dictionaries, and serializing it back to those formats.

```python
from h2ogpte.rest_async.models.user_configuration_item import UserConfigurationItem

# TODO update the JSON string below
json = "{}"
# create an instance of UserConfigurationItem from a JSON string
user_configuration_item_instance = UserConfigurationItem.from_json(json)
# print the JSON string representation of the object
print(UserConfigurationItem.to_json())

# convert the object into a dict
user_configuration_item_dict = user_configuration_item_instance.to_dict()
# create an instance of UserConfigurationItem from a dict
user_configuration_item_from_dict = UserConfigurationItem.from_dict(user_configuration_item_dict)
```

--------------------------------

### _get_secret(secret_id)

Source: https://h2oai.github.io/h2ogpte/h2ogpte.html

Get a secret from the SecureStore by its ID.

```APIDOC
## _get_secret(secret_id)

### Description
Get a secret from the SecureStore by its ID.

### Parameters
- **secret_id** (str) - Required - The ID of the secret to retrieve.

### Returns
- **Dict[str, Any] | None** - The secret object corresponding to the provided ID.
```

--------------------------------

### answer_question

Source: https://h2oai.github.io/h2ogpte/h2ogpte.html

Send a message and get a response from an LLM.

```APIDOC
## _async _answer_question(question, system_prompt, pre_prompt_query, prompt_query, text_context_list, llm, llm_args, chat_conversation, guardrails_settings, timeout, **kwargs)

### Description
Send a message and get a response from an LLM. Note: This method is only recommended if you are passing a chat conversation or for low-volume testing.

### Parameters
- **question** (str) - Required - Text query to send to the LLM.
- **system_prompt** (str) - Optional - Text sent to models which support system prompts.
- **text_context_list** (List[str]) - Optional - List of raw text strings to be included.
- **llm** (str | int) - Optional - Name or index of LLM to send the query.
- **llm_args** (Dict[str, Any]) - Optional - Dictionary of kwargs to pass to the llm (e.g., temperature, seed, top_k, top_p, repetition_penalty, max_new_tokens).

### Response
- **Returns** (Answer) - The response object from the LLM.
```

--------------------------------

### Initialize and Serialize Document Model

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/Document.md.txt

Demonstrates how to create a Document instance from JSON or a dictionary and convert it back to those formats.

```python
from h2ogpte.rest_async.models.document import Document

# TODO update the JSON string below
json = "{}"
# create an instance of Document from a JSON string
document_instance = Document.from_json(json)
# print the JSON string representation of the object
print(Document.to_json())

# convert the object into a dict
document_dict = document_instance.to_dict()
# create an instance of Document from a dict
document_from_dict = Document.from_dict(document_dict)
```

--------------------------------

### Initialize and Convert H2OGPTSystemInfo

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/H2OGPTSystemInfo.md.txt

Demonstrates how to instantiate the H2OGPTSystemInfo model from JSON or a dictionary and convert it back to these formats.

```python
from h2ogpte.rest_async.models.h2_ogpt_system_info import H2OGPTSystemInfo

# TODO update the JSON string below
json = "{}"
# create an instance of H2OGPTSystemInfo from a JSON string
h2_ogpt_system_info_instance = H2OGPTSystemInfo.from_json(json)
# print the JSON string representation of the object
print(H2OGPTSystemInfo.to_json())

# convert the object into a dict
h2_ogpt_system_info_dict = h2_ogpt_system_info_instance.to_dict()
# create an instance of H2OGPTSystemInfo from a dict
h2_ogpt_system_info_from_dict = H2OGPTSystemInfo.from_dict(h2_ogpt_system_info_dict)
```

--------------------------------

### get_user_configurations()

Source: https://h2oai.github.io/h2ogpte/h2ogpte.html

Gets the user configurations for the current user.

```APIDOC
## get_user_configurations()

### Description
Gets the user configurations for the current user.

### Returns
- **List[ConfigItem]** - List of user configurations.
```

--------------------------------

### H2OGPTE.answer_question

Source: https://h2oai.github.io/h2ogpte/h2ogpte.html

Send a message and get a response from an LLM.

```APIDOC
## H2OGPTE.answer_question

### Description
Send a message and get a response from an LLM. Note: This method is only recommended if you are passing a chat conversation or for low-volume testing.

### Parameters
- **question** (str) - Required - Text query to send to the LLM.
- **system_prompt** (str) - Optional - Text sent to models which support system prompts.
- **text_context_list** (List[str]) - Optional - List of raw text strings to be included as context.
- **llm** (str | int) - Optional - Name or index of LLM to send the query.

### Returns
- **Answer** - The response object from the LLM.
```

--------------------------------

### List available LLMs with Python

Source: https://h2oai.github.io/h2ogpte/_sources/examples/llms/example2.rst.txt

Initializes the H2OGPTE client and prints the names of all available models.

```python
from h2ogpte import H2OGPTE

client = H2OGPTE(
    address="https://h2ogpte.genai.h2o.ai",
    api_key='sk-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX',
)

for item in client.get_llm_names():
    print(item)
```

--------------------------------

### Example output of LLM usage metrics

Source: https://h2oai.github.io/h2ogpte/_sources/examples/llms/example7.rst.txt

Sample output format showing the structure of the retrieved usage data for different LLMs.

```text
Call count: 7
Input tokens: 256952
LLM cost: 0.998826
LLM name: claude-3-5-sonnet-20240620
Model computed fields: {}
Model configuration: {}
Model fields: {'llm_name': FieldInfo(annotation=str, required=True), 'llm_cost': FieldInfo(annotation=float, required=True), 'call_count': FieldInfo(annotation=int, required=True), 'input_tokens': FieldInfo(annotation=int, required=True), 'output_tokens': FieldInfo(annotation=int, required=True)}
Output tokens: 15198
----------------------------------------------------------------------------------------------------
Call count: 9
Input tokens: 76554
LLM cost: 0.02205975
LLM name: claude-3-haiku-20240307
Model computed fields: {}
Model configuration: {}
Model fields: {'llm_name': FieldInfo(annotation=str, required=True), 'llm_cost': FieldInfo(annotation=float, required=True), 'call_count': FieldInfo(annotation=int, required=True), 'input_tokens': FieldInfo(annotation=int, required=True), 'output_tokens': FieldInfo(annotation=int, required=True)}
Output tokens: 2337
....
```

--------------------------------

### GET /agents/tool-association

Source: https://h2oai.github.io/h2ogpte/rest_sync/AgentsApi.html

Returns a list of tools and the user.

```APIDOC
## GET /agents/tool-association

### Description
Returns a list of tools and the user.

### Method
GET

### Endpoint
/agents/tool-association
```

--------------------------------

### Initialize and Convert AgentToolKeyAssociations in Python

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/AgentToolKeyAssociations.md.txt

Demonstrates creating an instance from JSON, converting to a dictionary, and back to an object.

```python
from h2ogpte.rest_async.models.agent_tool_key_associations import AgentToolKeyAssociations

# TODO update the JSON string below
json = "{}"
# create an instance of AgentToolKeyAssociations from a JSON string
agent_tool_key_associations_instance = AgentToolKeyAssociations.from_json(json)
# print the JSON string representation of the object
print(AgentToolKeyAssociations.to_json())

# convert the object into a dict
agent_tool_key_associations_dict = agent_tool_key_associations_instance.to_dict()
# create an instance of AgentToolKeyAssociations from a dict
agent_tool_key_associations_from_dict = AgentToolKeyAssociations.from_dict(agent_tool_key_associations_dict)
```

--------------------------------

### GET /secrets/{secret-id}

Source: https://h2oai.github.io/h2ogpte/rest_async/SecretsApi.html

Retrieves a secret by its ID.

```APIDOC
## GET /secrets/{secret-id}

### Description
Get a secret by ID.

### Method
GET

### Endpoint
/secrets/{secret-id}

### Parameters
#### Path Parameters
- **secret-id** (string) - Required
```

--------------------------------

### GET /tags/{tag-name}

Source: https://h2oai.github.io/h2ogpte/rest_async/TagsApi.html

Finds a tag by its name.

```APIDOC
## GET /tags/{tag-name}

### Description
Finds a tag by its name.

### Method
GET

### Endpoint
/tags/{tag-name}

### Parameters
#### Path Parameters
- **tag-name** (string) - Required - The name of the tag to retrieve.
```

--------------------------------

### Interact with a website using h2oGPTe

Source: https://h2oai.github.io/h2ogpte/_sources/tutorials/tutorial1/tutorial1.rst.txt

Initializes the client, creates a collection, ingests a website, and performs a query. Requires an active h2oGPTe instance and a valid global API key.

```python
from h2ogpte import H2OGPTE

# Step 1: Set up client
# Instantiate an h2oGPTe client by providing:
# - address (address): Specifies the URL where Enterprise h2oGPTe is hosted. The address should be where the API key was created. 
# - global API key (api_key): Provides full system-wide access to all collections, documents, chats, and settings within the h2oGPTe service, allowing for secure communication and interaction with all aspects of your work. 
client = H2OGPTE(
    address="https://h2ogpte.genai.h2o.ai",
    api_key='sk-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX',
)

# Step 2: Create a Collection
collection_id = client.create_collection(
    name="Chat with website",
    description="Chat with the H2O Label Genie documentation website",
)

# Step 3: Crawl website
website = client.ingest_website(
    collection_id=collection_id, 
    url="https://docs.h2o.ai/wave-apps/h2o-label-genie/"
)

# Step 4: Initiate a chat session 
chat_session_id = client.create_chat_session(collection_id=collection_id)

with client.connect(chat_session_id) as session:

    # Step 5: Chat with the website
    reply = session.query("What is H2O Label Genie?")

    print(
        f"Content: {reply.content}\n" # Response to the sent query
        f"Created at: {reply.created_at}\n"
        f"Error: {reply.error}\n"
        f"ID: {reply.id}\n"
        f"Model computed fields: {reply.model_computed_fields}\n"
        f"Model config: {reply.model_config}\n"
        f"Model fields: {reply.model_fields}\n"
        f"Reply to: {reply.reply_to}\n"
        f"Type list: {reply.type_list}\n"
        f"Votes: {reply.votes}"
    )
```

--------------------------------

### GET /configurations

Source: https://h2oai.github.io/h2ogpte/rest_async/ConfigurationsApi.html

Retrieves all global configuration items.

```APIDOC
## GET /configurations

### Description
Gets global configurations.

### Method
GET

### Endpoint
/configurations
```

--------------------------------

### Initialize and Serialize IngestFromFileSystemBody in Python

Source: https://h2oai.github.io/h2ogpte/_sources/rest_sync/IngestFromFileSystemBody.md.txt

Demonstrates how to instantiate the model from JSON or a dictionary and convert it back to these formats.

```python
from h2ogpte.rest_sync.models.ingest_from_file_system_body import IngestFromFileSystemBody

# TODO update the JSON string below
json = "{}"
# create an instance of IngestFromFileSystemBody from a JSON string
ingest_from_file_system_body_instance = IngestFromFileSystemBody.from_json(json)
# print the JSON string representation of the object
print(IngestFromFileSystemBody.to_json())

# convert the object into a dict
ingest_from_file_system_body_dict = ingest_from_file_system_body_instance.to_dict()
# create an instance of IngestFromFileSystemBody from a dict
ingest_from_file_system_body_from_dict = IngestFromFileSystemBody.from_dict(ingest_from_file_system_body_dict)
```

--------------------------------

### GET /roles

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/PermissionsApi.md.txt

Returns all roles for in the H2OGPTe instance.

```APIDOC
## GET /roles

### Description
Returns all roles for in the H2OGPTe instance.

### Method
GET

### Endpoint
/roles
```

--------------------------------

### Initialize Client and Ingest Documents

Source: https://h2oai.github.io/h2ogpte/_sources/getting_started.rst.txt

Establishes a connection to the h2oGPTe server, creates a chat session, and uploads documents to a collection for processing.

```python
from h2ogpte import H2OGPTE

client = H2OGPTE(
    address="https://h2ogpte.genai.h2o.ai",
    api_key=API_KEY)

# Chat with LLM
chat_session_id = client.create_chat_session()
with client.connect(chat_session_id) as session:
    # Simple Question for Document Collection
    answer = session.query(
        "Can you hallucinate?",
    ).content
    print(answer)

# Create Collection
collection_id = client.create_collection(
    name="My first h2oGPTe collection",
    description="PDF -> text -> summary",
)

file_path = "...path to document(s)..."
with open(file_path.resolve(), "rb") as f:
    upload_id = client.upload(file_path.name, f)

# Converting the input into chunked text and embeddings...
client.ingest_uploads(collection_id, [upload_id])
```

--------------------------------

### GET /question_answer_feedbacks/count

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/ChatApi.md.txt

Counts the number of question-answer feedbacks.

```APIDOC
## GET /question_answer_feedbacks/count

### Description
Counts a number of question-answer feedbacks.

### Method
GET

### Endpoint
/question_answer_feedbacks/count
```

--------------------------------

### Instantiate and Serialize UserInfo in Python

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/UserInfo.md.txt

Demonstrates creating a UserInfo instance from JSON or a dictionary and converting it back to those formats.

```python
from h2ogpte.rest_async.models.user_info import UserInfo

# TODO update the JSON string below
json = "{}"
# create an instance of UserInfo from a JSON string
user_info_instance = UserInfo.from_json(json)
# print the JSON string representation of the object
print(UserInfo.to_json())

# convert the object into a dict
user_info_dict = user_info_instance.to_dict()
# create an instance of UserInfo from a dict
user_info_from_dict = UserInfo.from_dict(user_info_dict)
```

--------------------------------

### Initialize and Convert IngestFromWebsiteBody

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/IngestFromWebsiteBody.md.txt

Demonstrates creating an instance from JSON or a dictionary and converting it back to those formats.

```python
from h2ogpte.rest_async.models.ingest_from_website_body import IngestFromWebsiteBody

# TODO update the JSON string below
json = "{}"
# create an instance of IngestFromWebsiteBody from a JSON string
ingest_from_website_body_instance = IngestFromWebsiteBody.from_json(json)
# print the JSON string representation of the object
print(IngestFromWebsiteBody.to_json())

# convert the object into a dict
ingest_from_website_body_dict = ingest_from_website_body_instance.to_dict()
# create an instance of IngestFromWebsiteBody from a dict
ingest_from_website_body_from_dict = IngestFromWebsiteBody.from_dict(ingest_from_website_body_dict)
```

--------------------------------

### GET /chats/count

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/ChatApi.md.txt

Counts the number of chat sessions.

```APIDOC
## GET /chats/count

### Description
Counts a number of chat sessions.

### Method
GET

### Endpoint
/chats/count
```

--------------------------------

### Configure Prompt Template and Sample Questions

Source: https://h2oai.github.io/h2ogpte/examples/prompts/example1.html

Defines a prompt template configuration including default sample questions and specific XML-based instructions for image batch processing.

```python
    'provided above. Respond in JSON, like this: {{"q1": "Question 1?", "q2": "Question 2?", ..., "q10": "Question 10?"}}.'
    ),
    default_sample_questions=[
        "Create five good questions",
        "Summarize in one sentence",
        "Explain this to a 5-year old",
        "Tell me something interesting",
    ],
    image_batch_image_prompt=(
        """<response_instructions>\n"""
        """- Act as a keen observer with a sharp eye for detail.\n"""
        """- Analyze the content within the images.\n"""
        """- Provide insights based on your observations.\n"""
        """- Avoid making up facts.\n"""
        """- Do not forget to follow the system prompt.\n"""
        """</response_instructions>"""
    ),
    image_batch_final_prompt=(
        """<response_instructions>\n"""
        """- Check if the answers already given in <image> XML tags are useful.\n"""
        """- Image answers came from a vision model capable of reading text and images within """
        """the images.\n"""
        """- If image answers are useful, preserve all details the image answers provide and use """
        """them to construct a well-structured answer.\n"""
        """- Ignore image answers that had no useful content, because any single batch of images """
        """may not be relevant. Focus on all details from image answers that are relevant and useful.\n"""
        """- Check if the document text can answer the question.\n"""
        """- Check if the chat history can answer the question.\n"""
        """- Check if any figure captions can answer the question.\n"""
        """- If answers conflict between text, chat history, and figure captions, do not focus """
        """your response on this conflict.\n"""
        """- In handling conflicting answers, use logical reasoning and supporting evidence to """
        """assess the plausibility of each answer.\n"""
        """- In handling conflicting answers, choose the most consistent answer -- i.e., the """
        """most common answer among conflicts (self-consistency reasoning) or one that aligns """
        """with well-established facts.\n"""
        """- In handling conflicting answers, one may choose one data source over another -- i.e., """
        """text is probably more reliable than an image when the question can be answered from """
        """text, while an image is more reliable than text for flowcharts, photos, etc.\n"""
        """- Do not forget to follow the system prompt.\n"""
        """- Finally, according to our chat history, the above documents, figure captions, or given """
        """images, construct a well-structured response.\n"""
        """</response_instructions>"""
    ),
)

print(prompt_template_id)
```

--------------------------------

### GET /embedding-models

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/ModelsApi.md.txt

Lists all available embedding models.

```APIDOC
## GET /embedding-models

### Description
Lists all available embedding models.

### Method
GET

### Endpoint
/embedding-models
```

--------------------------------

### Create an API key for a user

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/APIKeysApi.md.txt

Demonstrates how to initialize the API client with Bearer authentication and invoke the create_api_key_for_user method.

```python
import h2ogpte.rest_async
from h2ogpte.rest_async.models.api_key_create_request import APIKeyCreateRequest
from h2ogpte.rest_async.models.api_key_result import APIKeyResult
from h2ogpte.rest_async.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to https://h2ogpte.genai.h2o.ai/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = h2ogpte.rest_async.Configuration(
    host = "https://h2ogpte.genai.h2o.ai/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure Bearer authorization: bearerAuth
configuration = h2ogpte.rest_async.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
async with h2ogpte.rest_async.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = h2ogpte.rest_async.APIKeysApi(api_client)
    api_key_create_request = h2ogpte.rest_async.APIKeyCreateRequest() # APIKeyCreateRequest | 

    try:
        # Create an API key
        api_response = await api_instance.create_api_key_for_user(api_key_create_request)
        print("The response of APIKeysApi->create_api_key_for_user:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling APIKeysApi->create_api_key_for_user: %s\n" % e)
```

--------------------------------

### GET /document-summaries/{summary-id}

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/DocumentsApi.md.txt

Fetches document summary.

```APIDOC
## GET /document-summaries/{summary-id}

### Description
Fetches document summary.

### Method
GET

### Endpoint
/document-summaries/{summary-id}

### Parameters
#### Path Parameters
- **summary-id** (string) - Required - The ID of the summary.
```

--------------------------------

### GET /documents/{document-id}

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/DocumentsApi.md.txt

Finds a document by id.

```APIDOC
## GET /documents/{document-id}

### Description
Finds a document by id.

### Method
GET

### Endpoint
/documents/{document-id}

### Parameters
#### Path Parameters
- **document-id** (string) - Required - The ID of the document.
```

--------------------------------

### List Global Configurations with Bearer Authentication

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/ConfigurationsApi.md.txt

Demonstrates how to initialize the API client with bearer token authentication and call the list_global_configurations endpoint.

```python
import h2ogpte.rest_async
from h2ogpte.rest_async.models.global_configuration_item import GlobalConfigurationItem
from h2ogpte.rest_async.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to https://h2ogpte.genai.h2o.ai/api/v1
# See configuration.py for a list of all supported configuration parameters.
configuration = h2ogpte.rest_async.Configuration(
    host = "https://h2ogpte.genai.h2o.ai/api/v1"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure Bearer authorization: bearerAuth
configuration = h2ogpte.rest_async.Configuration(
    access_token = os.environ["BEARER_TOKEN"]
)

# Enter a context with an instance of the API client
async with h2ogpte.rest_async.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = h2ogpte.rest_async.ConfigurationsApi(api_client)
    as_admin = False # bool | If set, lists global configurations with admin permissions. The user must be admin. (optional) (default to False)

    try:
        # Gets global configurations.
        api_response = await api_instance.list_global_configurations(as_admin=as_admin)
        print("The response of ConfigurationsApi->list_global_configurations:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling ConfigurationsApi->list_global_configurations: %s\n" % e)
```

--------------------------------

### GET /stats/usage

Source: https://h2oai.github.io/h2ogpte/_sources/rest_async/ModelsApi.md.txt

Returns usage statistics for all models.

```APIDOC
## GET /stats/usage

### Description
Returns usage statistics for all models.

### Method
GET

### Endpoint
/stats/usage
```
Tokens:
Raw