h2ogpte 1.6.55rc1__py3-none-any.whl → 1.7.0rc2__py3-none-any.whl

h2ogpte/rest_async/models/chat_completion_request.py

@@ -19,6 +19,7 @@ import json
 
 from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
 from typing import Any, ClassVar, Dict, List, Optional
+from h2ogpte.rest_async.models.chat_settings_tags import ChatSettingsTags
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -37,7 +38,7 @@ class ChatCompletionRequest(BaseModel):
     self_reflection_config: Optional[Dict[str, Any]] = Field(default=None, description="A map with self reflection settings:   * `llm_reflection` **(type=string, example=gpt-4-0613)**   * `prompt_reflection` **(type=string, example=\\\"\\\"\\\"Prompt:\\\\\\\\n%s\\\\\\\\n\\\"\\\"\\\"\\\\\\\\n\\\\\\\\n\\\"\\\"\\\")**   * `system_prompt_reflection` **(type=string)**   * `llm_args_reflection` **(type=string, example={})** ")
     rag_config: Optional[Dict[str, Any]] = Field(default=None, description="A map with arguments to control RAG (retrieval-augmented-generation) types.:   * `rag_type` **(type=enum[auto, llm_only, rag, hyde1, hyde2, rag+, all_data])** RAG type options:     * `auto` - Automatically select the best rag_type.     * `llm_only` LLM Only - Answer the query without any supporting document contexts.        Requires 1 LLM call.     * `rag` RAG (Retrieval Augmented Generation) - Use supporting document contexts        to answer the query. Requires 1 LLM call.     * `hyde1` LLM Only + RAG composite - HyDE RAG (Hypothetical Document Embedding).        Use 'LLM Only' response to find relevant contexts from a collection for generating        a response. Requires 2 LLM calls.     * `hyde2` HyDE + RAG composite - Use the 'HyDE RAG' response to find relevant        contexts from a collection for generating a response. Requires 3 LLM calls.     * `rag+` Summary RAG - Like RAG, but uses more context and recursive        summarization to overcome LLM context limits. Keeps all retrieved chunks, puts        them in order, adds neighboring chunks, then uses the summary API to get the        answer. Can require several LLM calls.     * `all_data` All Data RAG - Like Summary RAG, but includes all document        chunks. Uses recursive summarization to overcome LLM context limits.        Can require several LLM calls.   * `hyde_no_rag_llm_prompt_extension` **(type=string, example=\\\\\\\\nKeep the answer brief, and list the 5 most relevant key words at the end.)** -     Add this prompt to every user's prompt, when generating answers to be used for subsequent retrieval during HyDE.     Only used when rag_type is `hyde1` or `hyde2`.   * `num_neighbor_chunks_to_include` **(type=integer, default=1)** - A number of neighboring chunks to include      for every retrieved relevant chunk. It helps to keep surrounding context together. Only enabled for rag_type `rag+`.   * `meta_data_to_include` **(type=map)** - A map with flags that indicate whether each piece of document metadata      is to be included as part of the context for a chat with a collection.     * `name` **(type: boolean, default=True)**     * `text` **(type: boolean, default=True)**     * `page` **(type: boolean, default=True)**     * `captions` **(type: boolean, default=True)**     * `uri` **(type: boolean, default=False)**     * `connector` **(type: boolean, default=False)**     * `original_mtime` **(type: boolean, default=False)**     * `age` **(type: boolean, default=False)**     * `score` **(type: boolean, default=False)**   * `rag_max_chunks` **(type=integer, default=-1)** - Maximum number of document chunks to retrieve for RAG.     Actual number depends on rag_type and admin configuration. Set to >0 values to enable.      Can be combined with rag_min_chunk_score.   * `rag_min_chunk_score` **(type=double, default=0.0)** - Minimum score of document chunks to retrieve for RAG.     Set to >0 values to enable. Can be combined with rag_max_chunks. ")
     include_chat_history: Optional[StrictStr] = Field(default=None, description="Whether to include chat history. Includes previous questions and answers for the current chat session for each new chat request. Disable if require deterministic answers for a given question.")
-    tags: Optional[List[StrictStr]] = Field(default=None, description="A list of tags from which to pull the context for RAG.")
+    tags: Optional[ChatSettingsTags] = None
     __properties: ClassVar[List[str]] = ["message", "system_prompt", "pre_prompt_query", "prompt_query", "image_batch_final_prompt", "image_batch_image_prompt", "llm", "llm_args", "self_reflection_config", "rag_config", "include_chat_history", "tags"]
 
     @field_validator('include_chat_history')
@@ -89,6 +90,9 @@ class ChatCompletionRequest(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
+        # override the default output from pydantic by calling `to_dict()` of tags
+        if self.tags:
+            _dict['tags'] = self.tags.to_dict()
         return _dict
 
     @classmethod
@@ -112,7 +116,7 @@ class ChatCompletionRequest(BaseModel):
             "self_reflection_config": obj.get("self_reflection_config"),
             "rag_config": obj.get("rag_config"),
             "include_chat_history": obj.get("include_chat_history"),
-            "tags": obj.get("tags"),
+            "tags": ChatSettingsTags.from_dict(obj["tags"]) if obj.get("tags") is not None else None,
         })
         return _obj
 

h2ogpte/rest_async/models/chat_settings.py

@@ -19,6 +19,7 @@ import json
 
 from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
 from typing import Any, ClassVar, Dict, List, Optional
+from h2ogpte.rest_async.models.chat_settings_tags import ChatSettingsTags
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -31,7 +32,7 @@ class ChatSettings(BaseModel):
     self_reflection_config: Optional[Dict[str, Any]] = Field(default=None, description="A map with self reflection settings:   * `llm_reflection` **(type=string, example=gpt-4-0613)**   * `prompt_reflection` **(type=string, example=\\\"\\\"\\\"Prompt:\\\\\\\\n%s\\\\\\\\n\\\"\\\"\\\"\\\\\\\\n\\\\\\\\n\\\"\\\"\\\")**   * `system_prompt_reflection` **(type=string)**   * `llm_args_reflection` **(type=string, example={})** ")
     rag_config: Optional[Dict[str, Any]] = Field(default=None, description="A map with arguments to control RAG (retrieval-augmented-generation) types.:   * `rag_type` **(type=enum[auto, llm_only, rag, hyde1, hyde2, rag+, all_data])** RAG type options:     * `auto` - Automatically select the best rag_type.     * `llm_only` LLM Only - Answer the query without any supporting document contexts.        Requires 1 LLM call.     * `rag` RAG (Retrieval Augmented Generation) - Use supporting document contexts        to answer the query. Requires 1 LLM call.     * `hyde1` LLM Only + RAG composite - HyDE RAG (Hypothetical Document Embedding).        Use 'LLM Only' response to find relevant contexts from a collection for generating        a response. Requires 2 LLM calls.     * `hyde2` HyDE + RAG composite - Use the 'HyDE RAG' response to find relevant        contexts from a collection for generating a response. Requires 3 LLM calls.     * `rag+` Summary RAG - Like RAG, but uses more context and recursive        summarization to overcome LLM context limits. Keeps all retrieved chunks, puts        them in order, adds neighboring chunks, then uses the summary API to get the        answer. Can require several LLM calls.     * `all_data` All Data RAG - Like Summary RAG, but includes all document        chunks. Uses recursive summarization to overcome LLM context limits.        Can require several LLM calls.   * `hyde_no_rag_llm_prompt_extension` **(type=string, example=\\\\\\\\nKeep the answer brief, and list the 5 most relevant key words at the end.)** -     Add this prompt to every user's prompt, when generating answers to be used for subsequent retrieval during HyDE.     Only used when rag_type is `hyde1` or `hyde2`.   * `num_neighbor_chunks_to_include` **(type=integer, default=1)** - A number of neighboring chunks to include      for every retrieved relevant chunk. It helps to keep surrounding context together. Only enabled for rag_type `rag+`.   * `meta_data_to_include` **(type=map)** - A map with flags that indicate whether each piece of document metadata      is to be included as part of the context for a chat with a collection.     * `name` **(type: boolean, default=True)**     * `text` **(type: boolean, default=True)**     * `page` **(type: boolean, default=True)**     * `captions` **(type: boolean, default=True)**     * `uri` **(type: boolean, default=False)**     * `connector` **(type: boolean, default=False)**     * `original_mtime` **(type: boolean, default=False)**     * `age` **(type: boolean, default=False)**     * `score` **(type: boolean, default=False)**   * `rag_max_chunks` **(type=integer, default=-1)** - Maximum number of document chunks to retrieve for RAG.     Actual number depends on rag_type and admin configuration. Set to >0 values to enable.      Can be combined with rag_min_chunk_score.   * `rag_min_chunk_score` **(type=double, default=0.0)** - Minimum score of document chunks to retrieve for RAG.     Set to >0 values to enable. Can be combined with rag_max_chunks. ")
     include_chat_history: Optional[StrictStr] = Field(default=None, description="Whether to include chat history. Includes previous questions and answers for the current chat session for each new chat request. Disable if require deterministic answers for a given question.")
-    tags: Optional[List[StrictStr]] = Field(default=None, description="A list of tags from which to pull the context for RAG.")
+    tags: Optional[ChatSettingsTags] = None
     __properties: ClassVar[List[str]] = ["llm", "llm_args", "self_reflection_config", "rag_config", "include_chat_history", "tags"]
 
     @field_validator('include_chat_history')
@@ -83,6 +84,9 @@ class ChatSettings(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
+        # override the default output from pydantic by calling `to_dict()` of tags
+        if self.tags:
+            _dict['tags'] = self.tags.to_dict()
         return _dict
 
     @classmethod
@@ -100,7 +104,7 @@ class ChatSettings(BaseModel):
             "self_reflection_config": obj.get("self_reflection_config"),
             "rag_config": obj.get("rag_config"),
             "include_chat_history": obj.get("include_chat_history"),
-            "tags": obj.get("tags")
+            "tags": ChatSettingsTags.from_dict(obj["tags"]) if obj.get("tags") is not None else None
         })
         return _obj
 

h2ogpte/rest_async/models/chat_settings_tags.py

@@ -0,0 +1,140 @@
+# coding: utf-8
+
+"""
+    h2oGPTe REST API
+
+     # Overview   Users can easily interact with the h2oGPTe API through its REST API, allowing HTTP requests from any programming language.  ## Authorization: Getting an API key  Sign up/in at Enterprise h2oGPTe and generate one of the following two types of API keys:   - **Global API key**: If a Collection is not specified when creating a new API Key, that key is considered to be a global API Key. Use global API Keys to grant full user impersonation and system-wide access to all of your work. Anyone with access to one of your global API Keys can create, delete, or interact with any of your past, current, and future Collections, Documents, Chats, and settings.  - **Collection-specific API key**: Use Collection-specific API Keys to grant external access to only Chat with a specified Collection and make related API calls to it. Collection-specific API keys do not allow other API calls, such as creation, deletion, or access to other Collections or Chats.   Access Enterprise h2oGPTe through your [H2O Generative AI](https://genai.h2o.ai/appstore) app store account, available with a freemium tier.  ## Authorization: Using an API key   All h2oGPTe REST API requests must include an API Key in the \"Authorization\" HTTP header, formatted as follows:  ``` Authorization: Bearer sk-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX ```  ```sh curl -X 'POST' \\   'https://h2ogpte.genai.h2o.ai/api/v1/collections' \\   -H 'accept: application/json' \\   -H 'Content-Type: application/json' \\   -H 'Authorization: Bearer sk-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX' \\   -d '{     \"name\": \"The name of my Collection\",     \"description\": \"The description of my Collection\",     \"embedding_model\": \"BAAI/bge-large-en-v1.5\"   }' ```      ## Interactive h2oGPTe API testing  This page only showcases the h2oGPTe REST API; you can test it directly in the [Swagger UI](https://h2ogpte.genai.h2o.ai/swagger-ui/). Ensure that you are logged into your Enterprise h2oGPTe account. 
+
+    The version of the OpenAPI document: v1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import json
+import pprint
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, ValidationError, field_validator
+from typing import Any, List, Optional
+from h2ogpte.rest_async.models.tag_filter import TagFilter
+from pydantic import StrictStr, Field
+from typing import Union, List, Set, Optional, Dict
+from typing_extensions import Literal, Self
+
+CHATSETTINGSTAGS_ONE_OF_SCHEMAS = ["List[str]", "TagFilter"]
+
+class ChatSettingsTags(BaseModel):
+    """
+    Filter documents by tags for RAG context. Supports two formats:   - Array format (backward compatible): [\"red\", \"blue\"] includes documents with 'red' OR 'blue' tags   - Object format (with exclusions): {\"include\": [\"color\"], \"exclude\": [\"red\", \"blue\"]} 
+    """
+    # data type: List[str]
+    oneof_schema_1_validator: Optional[List[StrictStr]] = None
+    # data type: TagFilter
+    oneof_schema_2_validator: Optional[TagFilter] = None
+    actual_instance: Optional[Union[List[str], TagFilter]] = None
+    one_of_schemas: Set[str] = { "List[str]", "TagFilter" }
+
+    model_config = ConfigDict(
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def __init__(self, *args, **kwargs) -> None:
+        if args:
+            if len(args) > 1:
+                raise ValueError("If a position argument is used, only 1 is allowed to set `actual_instance`")
+            if kwargs:
+                raise ValueError("If a position argument is used, keyword arguments cannot be used.")
+            super().__init__(actual_instance=args[0])
+        else:
+            super().__init__(**kwargs)
+
+    @field_validator('actual_instance')
+    def actual_instance_must_validate_oneof(cls, v):
+        instance = ChatSettingsTags.model_construct()
+        error_messages = []
+        match = 0
+        # validate data type: List[str]
+        try:
+            instance.oneof_schema_1_validator = v
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # validate data type: TagFilter
+        if not isinstance(v, TagFilter):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `TagFilter`")
+        else:
+            match += 1
+        if match > 1:
+            # more than 1 match
+            raise ValueError("Multiple matches found when setting `actual_instance` in ChatSettingsTags with oneOf schemas: List[str], TagFilter. Details: " + ", ".join(error_messages))
+        elif match == 0:
+            # no match
+            raise ValueError("No match found when setting `actual_instance` in ChatSettingsTags with oneOf schemas: List[str], TagFilter. Details: " + ", ".join(error_messages))
+        else:
+            return v
+
+    @classmethod
+    def from_dict(cls, obj: Union[str, Dict[str, Any]]) -> Self:
+        return cls.from_json(json.dumps(obj))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Returns the object represented by the json string"""
+        instance = cls.model_construct()
+        error_messages = []
+        match = 0
+
+        # deserialize data into List[str]
+        try:
+            # validation
+            instance.oneof_schema_1_validator = json.loads(json_str)
+            # assign value to actual_instance
+            instance.actual_instance = instance.oneof_schema_1_validator
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # deserialize data into TagFilter
+        try:
+            instance.actual_instance = TagFilter.from_json(json_str)
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+
+        if match > 1:
+            # more than 1 match
+            raise ValueError("Multiple matches found when deserializing the JSON string into ChatSettingsTags with oneOf schemas: List[str], TagFilter. Details: " + ", ".join(error_messages))
+        elif match == 0:
+            # no match
+            raise ValueError("No match found when deserializing the JSON string into ChatSettingsTags with oneOf schemas: List[str], TagFilter. Details: " + ", ".join(error_messages))
+        else:
+            return instance
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the actual instance"""
+        if self.actual_instance is None:
+            return "null"
+
+        if hasattr(self.actual_instance, "to_json") and callable(self.actual_instance.to_json):
+            return self.actual_instance.to_json()
+        else:
+            return json.dumps(self.actual_instance)
+
+    def to_dict(self) -> Optional[Union[Dict[str, Any], List[str], TagFilter]]:
+        """Returns the dict representation of the actual instance"""
+        if self.actual_instance is None:
+            return None
+
+        if hasattr(self.actual_instance, "to_dict") and callable(self.actual_instance.to_dict):
+            return self.actual_instance.to_dict()
+        else:
+            # primitive type
+            return self.actual_instance
+
+    def to_str(self) -> str:
+        """Returns the string representation of the actual instance"""
+        return pprint.pformat(self.model_dump())
+
+

h2ogpte/rest_async/models/extractor.py

@@ -18,8 +18,9 @@ import re  # noqa: F401
 import json
 
 from datetime import datetime
-from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictInt, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
+from h2ogpte.rest_async.models.guardrails_settings import GuardrailsSettings
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -31,10 +32,20 @@ class Extractor(BaseModel):
     description: StrictStr = Field(description="What this extractor does")
     llm: Optional[StrictStr] = Field(default=None, description="(Optional) Identifier or version of the language model the extractor uses")
     var_schema: Optional[StrictStr] = Field(default=None, description="(Optional) JSONSchema (or other spec) that the extractor outputs", alias="schema")
+    prompt: Optional[StrictStr] = Field(default=None, description="(Optional) Prompt text for the extractor")
+    pre_prompt_summary: Optional[StrictStr] = Field(default=None, description="(Optional) Pre-prompt summary text for the extractor")
+    keep_intermediate_results: Optional[StrictBool] = Field(default=None, description="(Optional) Flag indicating whether to keep intermediate results during extraction")
+    system_prompt: Optional[StrictStr] = Field(default=None, description="(Optional) System prompt text for the extractor")
+    max_num_chunks: Optional[StrictInt] = Field(default=None, description="(Optional) Maximum number of chunks to process")
+    vision: Optional[StrictStr] = Field(default=None, description="(Optional) Vision mode setting")
+    vision_llm: Optional[StrictStr] = Field(default=None, description="(Optional) Vision LLM model identifier")
+    image_batch_image_prompt: Optional[StrictStr] = Field(default=None, description="(Optional) Image batch processing prompt")
+    image_batch_final_prompt: Optional[StrictStr] = Field(default=None, description="(Optional) Final prompt for image batch processing")
+    guardrails_settings: Optional[GuardrailsSettings] = None
     id: StrictStr = Field(description="Unique identifier of the extractor")
     is_public: StrictBool = Field(description="Flag indicating if the extractor is public")
     created_at: datetime = Field(description="When the extractor definition was created")
-    __properties: ClassVar[List[str]] = ["name", "description", "llm", "schema", "id", "is_public", "created_at"]
+    __properties: ClassVar[List[str]] = ["name", "description", "llm", "schema", "prompt", "pre_prompt_summary", "keep_intermediate_results", "system_prompt", "max_num_chunks", "vision", "vision_llm", "image_batch_image_prompt", "image_batch_final_prompt", "guardrails_settings", "id", "is_public", "created_at"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -75,6 +86,9 @@ class Extractor(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
+        # override the default output from pydantic by calling `to_dict()` of guardrails_settings
+        if self.guardrails_settings:
+            _dict['guardrails_settings'] = self.guardrails_settings.to_dict()
         return _dict
 
     @classmethod
@@ -91,6 +105,16 @@ class Extractor(BaseModel):
             "description": obj.get("description"),
             "llm": obj.get("llm"),
             "schema": obj.get("schema"),
+            "prompt": obj.get("prompt"),
+            "pre_prompt_summary": obj.get("pre_prompt_summary"),
+            "keep_intermediate_results": obj.get("keep_intermediate_results"),
+            "system_prompt": obj.get("system_prompt"),
+            "max_num_chunks": obj.get("max_num_chunks"),
+            "vision": obj.get("vision"),
+            "vision_llm": obj.get("vision_llm"),
+            "image_batch_image_prompt": obj.get("image_batch_image_prompt"),
+            "image_batch_final_prompt": obj.get("image_batch_final_prompt"),
+            "guardrails_settings": GuardrailsSettings.from_dict(obj["guardrails_settings"]) if obj.get("guardrails_settings") is not None else None,
             "id": obj.get("id"),
             "is_public": obj.get("is_public"),
             "created_at": obj.get("created_at")

h2ogpte/rest_async/models/extractor_create_request.py

@@ -17,8 +17,9 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, Field, StrictStr
-from typing import Any, ClassVar, Dict, List
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from h2ogpte.rest_async.models.guardrails_settings import GuardrailsSettings
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -29,8 +30,18 @@ class ExtractorCreateRequest(BaseModel):
     name: StrictStr = Field(description="Human-readable name")
     description: StrictStr = Field(description="What this extractor does")
     llm: StrictStr = Field(description="Identifier or version of the language model the extractor uses")
-    var_schema: StrictStr = Field(description="JSONSchema (or other spec) that the extractor outputs", alias="schema")
-    __properties: ClassVar[List[str]] = ["name", "description", "llm", "schema"]
+    var_schema: StrictStr = Field(description="JSONSchema (or other spec) that the extractor outputs. When schema is valid and not empty, the output will be always returned as JSON object.", alias="schema")
+    prompt: Optional[StrictStr] = Field(default=None, description="Custom prompt text for the extractor. If empty, default prompt will be used. If combined with schema, prompt can customize the output, but cannot change its format as it will always be JSON object.")
+    pre_prompt_summary: Optional[StrictStr] = Field(default=None, description="(Optional) Pre-prompt summary text for the extractor")
+    keep_intermediate_results: Optional[StrictBool] = Field(default=None, description="(Optional) Flag indicating whether to keep intermediate results during extraction")
+    system_prompt: Optional[StrictStr] = Field(default=None, description="(Optional) System prompt text for the extractor")
+    max_num_chunks: Optional[StrictInt] = Field(default=None, description="(Optional) Maximum number of chunks to process")
+    vision: Optional[StrictStr] = Field(default=None, description="(Optional) Vision mode setting")
+    vision_llm: Optional[StrictStr] = Field(default=None, description="(Optional) Vision LLM model identifier")
+    image_batch_image_prompt: Optional[StrictStr] = Field(default=None, description="(Optional) Image batch processing prompt")
+    image_batch_final_prompt: Optional[StrictStr] = Field(default=None, description="(Optional) Final prompt for image batch processing")
+    guardrails_settings: Optional[GuardrailsSettings] = None
+    __properties: ClassVar[List[str]] = ["name", "description", "llm", "schema", "prompt", "pre_prompt_summary", "keep_intermediate_results", "system_prompt", "max_num_chunks", "vision", "vision_llm", "image_batch_image_prompt", "image_batch_final_prompt", "guardrails_settings"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -71,6 +82,9 @@ class ExtractorCreateRequest(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
+        # override the default output from pydantic by calling `to_dict()` of guardrails_settings
+        if self.guardrails_settings:
+            _dict['guardrails_settings'] = self.guardrails_settings.to_dict()
         return _dict
 
     @classmethod
@@ -86,7 +100,17 @@ class ExtractorCreateRequest(BaseModel):
             "name": obj.get("name"),
             "description": obj.get("description"),
             "llm": obj.get("llm"),
-            "schema": obj.get("schema")
+            "schema": obj.get("schema"),
+            "prompt": obj.get("prompt"),
+            "pre_prompt_summary": obj.get("pre_prompt_summary"),
+            "keep_intermediate_results": obj.get("keep_intermediate_results"),
+            "system_prompt": obj.get("system_prompt"),
+            "max_num_chunks": obj.get("max_num_chunks"),
+            "vision": obj.get("vision"),
+            "vision_llm": obj.get("vision_llm"),
+            "image_batch_image_prompt": obj.get("image_batch_image_prompt"),
+            "image_batch_final_prompt": obj.get("image_batch_final_prompt"),
+            "guardrails_settings": GuardrailsSettings.from_dict(obj["guardrails_settings"]) if obj.get("guardrails_settings") is not None else None
         })
         return _obj
 

h2ogpte/rest_async/models/ingest_from_confluence_body.py

@@ -17,7 +17,7 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
 from h2ogpte.rest_async.models.confluence_credentials import ConfluenceCredentials
 from typing import Optional, Set
@@ -29,9 +29,10 @@ class IngestFromConfluenceBody(BaseModel):
     """ # noqa: E501
     base_url: StrictStr = Field(description="Base url of the confluence instance.")
     page_ids: List[StrictStr] = Field(description="Ids of pages to be ingested.")
+    include_attachments: Optional[StrictBool] = Field(default=False, description="A flag indicating whether to also ingest attachments with the page.")
     credentials: ConfluenceCredentials
     metadata: Optional[Dict[str, Any]] = Field(default=None, description="Metadata for the documents.")
-    __properties: ClassVar[List[str]] = ["base_url", "page_ids", "credentials", "metadata"]
+    __properties: ClassVar[List[str]] = ["base_url", "page_ids", "include_attachments", "credentials", "metadata"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -89,6 +90,7 @@ class IngestFromConfluenceBody(BaseModel):
         _obj = cls.model_validate({
             "base_url": obj.get("base_url"),
             "page_ids": obj.get("page_ids"),
+            "include_attachments": obj.get("include_attachments") if obj.get("include_attachments") is not None else False,
             "credentials": ConfluenceCredentials.from_dict(obj["credentials"]) if obj.get("credentials") is not None else None,
             "metadata": obj.get("metadata")
         })

h2ogpte/rest_async/models/{create_topic_model_job_request.py → tag_filter.py}

@@ -17,17 +17,18 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, StrictStr
-from typing import Any, ClassVar, Dict, List
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
 from typing import Optional, Set
 from typing_extensions import Self
 
-class CreateTopicModelJobRequest(BaseModel):
+class TagFilter(BaseModel):
     """
-    CreateTopicModelJobRequest
+    Filter for document tags supporting inclusion and exclusion.  Note: The exclude list takes priority over the include list. If a document has a tag that appears in both lists, the document will be excluded.  Examples:   - Include only documents with 'red' OR 'blue' tags: {\"include\": [\"red\", \"blue\"]}   - Exclude documents with 'red' OR 'blue' tags: {\"exclude\": [\"red\", \"blue\"]}   - Include documents with 'color' tag BUT exclude 'red' and 'blue': {\"include\": [\"color\"], \"exclude\": [\"red\", \"blue\"]} 
     """ # noqa: E501
-    collection_id: StrictStr
-    __properties: ClassVar[List[str]] = ["collection_id"]
+    include: Optional[List[StrictStr]] = Field(default=None, description="Include documents with ANY of these tags (OR operation).")
+    exclude: Optional[List[StrictStr]] = Field(default=None, description="Exclude documents with ANY of these tags (OR operation). Takes priority over include.")
+    __properties: ClassVar[List[str]] = ["include", "exclude"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -47,7 +48,7 @@ class CreateTopicModelJobRequest(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of CreateTopicModelJobRequest from a JSON string"""
+        """Create an instance of TagFilter from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -72,7 +73,7 @@ class CreateTopicModelJobRequest(BaseModel):
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of CreateTopicModelJobRequest from a dict"""
+        """Create an instance of TagFilter from a dict"""
         if obj is None:
             return None
 
@@ -80,7 +81,8 @@ class CreateTopicModelJobRequest(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "collection_id": obj.get("collection_id")
+            "include": obj.get("include"),
+            "exclude": obj.get("exclude")
         })
         return _obj
 

h2ogpte/rest_sync/__init__.py

@@ -14,7 +14,7 @@
 """  # noqa: E501
 
 
-__version__ = "1.6.55-dev1"
+__version__ = "1.7.0-dev2"
 
 # import apis into sdk package
 from h2ogpte.rest_sync.api.api_keys_api import APIKeysApi
@@ -69,6 +69,7 @@ from h2ogpte.rest_sync.models.chat_message_reference import ChatMessageReference
 from h2ogpte.rest_sync.models.chat_session import ChatSession
 from h2ogpte.rest_sync.models.chat_session_update_request import ChatSessionUpdateRequest
 from h2ogpte.rest_sync.models.chat_settings import ChatSettings
+from h2ogpte.rest_sync.models.chat_settings_tags import ChatSettingsTags
 from h2ogpte.rest_sync.models.chunk import Chunk
 from h2ogpte.rest_sync.models.chunk_search_result import ChunkSearchResult
 from h2ogpte.rest_sync.models.collection import Collection
@@ -88,7 +89,6 @@ from h2ogpte.rest_sync.models.create_import_collection_to_collection_job_request
 from h2ogpte.rest_sync.models.create_insert_document_to_collection_job_request import CreateInsertDocumentToCollectionJobRequest
 from h2ogpte.rest_sync.models.create_secret201_response import CreateSecret201Response
 from h2ogpte.rest_sync.models.create_secret_request import CreateSecretRequest
-from h2ogpte.rest_sync.models.create_topic_model_job_request import CreateTopicModelJobRequest
 from h2ogpte.rest_sync.models.delete_chat_sessions_job_request import DeleteChatSessionsJobRequest
 from h2ogpte.rest_sync.models.delete_collections_job_request import DeleteCollectionsJobRequest
 from h2ogpte.rest_sync.models.delete_documents_job_request import DeleteDocumentsJobRequest
@@ -158,6 +158,7 @@ from h2ogpte.rest_sync.models.suggested_question import SuggestedQuestion
 from h2ogpte.rest_sync.models.summarize_request import SummarizeRequest
 from h2ogpte.rest_sync.models.tag import Tag
 from h2ogpte.rest_sync.models.tag_create_request import TagCreateRequest
+from h2ogpte.rest_sync.models.tag_filter import TagFilter
 from h2ogpte.rest_sync.models.tag_update_request import TagUpdateRequest
 from h2ogpte.rest_sync.models.update_agent_key_request import UpdateAgentKeyRequest
 from h2ogpte.rest_sync.models.update_agent_tool_preference_request import UpdateAgentToolPreferenceRequest

h2ogpte/rest_sync/api/agents_api.py

@@ -16,7 +16,7 @@ from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
 from typing import Any, Dict, List, Optional, Tuple, Union
 from typing_extensions import Annotated
 
-from pydantic import Field, StrictBytes, StrictInt, StrictStr
+from pydantic import Field, StrictBytes, StrictInt, StrictStr, field_validator
 from typing import List, Optional, Tuple, Union
 from typing_extensions import Annotated
 from h2ogpte.rest_sync.models.add_custom_agent_tool201_response_inner import AddCustomAgentTool201ResponseInner
@@ -54,11 +54,11 @@ class AgentsApi:
     @validate_call
     def add_custom_agent_tool(
         self,
-        tool_type: StrictStr,
-        tool_args: StrictStr,
-        file: Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]] = None,
+        tool_type: Annotated[StrictStr, Field(description="The type of custom tool being added: - local_mcp: Model Context Protocol server running locally - remote_mcp: Model Context Protocol server running remotely - browser_action: Custom browser automation actions - general_code: General purpose code execution tools ")],
+        tool_args: Annotated[StrictStr, Field(description="JSON string containing tool-specific arguments. The structure varies by tool_type:  For remote_mcp: {   \\\"mcp_config_json\\\": \\\"JSON string with MCP server configuration\\\",   \\\"enable_by_default\\\": true/false (optional, defaults to true) }  For local_mcp, browser_action, and general_code: {   \\\"tool_name\\\": \\\"string (optional, defaults to filename without extension)\\\",   \\\"description\\\": \\\"string (optional, tool description)\\\",   \\\"enable_by_default\\\": true/false (optional, defaults to true),   \\\"should_unzip\\\": true/false (optional, for general_code .zip files only),   \\\"tool_usage_mode\\\": [\\\"runner\\\", \\\"creator\\\"] (optional list of strings) } ")],
+        file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The tool file to upload. Requirements vary by tool_type: - local_mcp: .zip file containing MCP server code - remote_mcp: Optional .json file with MCP configuration - browser_action: .py file (must start with 'browser_') or .zip containing browser action scripts - general_code: .py or .zip file with custom code ")] = None,
         custom_tool_path: Optional[StrictStr] = None,
-        filename: Optional[StrictStr] = None,
+        filename: Annotated[Optional[StrictStr], Field(description="Optional filename to use when storing the uploaded file")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -76,15 +76,15 @@ class AgentsApi:
 
         Add Custom Agent Tools
 
-        :param tool_type: (required)
+        :param tool_type: The type of custom tool being added: - local_mcp: Model Context Protocol server running locally - remote_mcp: Model Context Protocol server running remotely - browser_action: Custom browser automation actions - general_code: General purpose code execution tools  (required)
         :type tool_type: str
-        :param tool_args: (required)
+        :param tool_args: JSON string containing tool-specific arguments. The structure varies by tool_type:  For remote_mcp: {   \\\"mcp_config_json\\\": \\\"JSON string with MCP server configuration\\\",   \\\"enable_by_default\\\": true/false (optional, defaults to true) }  For local_mcp, browser_action, and general_code: {   \\\"tool_name\\\": \\\"string (optional, defaults to filename without extension)\\\",   \\\"description\\\": \\\"string (optional, tool description)\\\",   \\\"enable_by_default\\\": true/false (optional, defaults to true),   \\\"should_unzip\\\": true/false (optional, for general_code .zip files only),   \\\"tool_usage_mode\\\": [\\\"runner\\\", \\\"creator\\\"] (optional list of strings) }  (required)
         :type tool_args: str
-        :param file:
+        :param file: The tool file to upload. Requirements vary by tool_type: - local_mcp: .zip file containing MCP server code - remote_mcp: Optional .json file with MCP configuration - browser_action: .py file (must start with 'browser_') or .zip containing browser action scripts - general_code: .py or .zip file with custom code 
         :type file: bytearray
         :param custom_tool_path:
         :type custom_tool_path: str
-        :param filename:
+        :param filename: Optional filename to use when storing the uploaded file
         :type filename: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -138,11 +138,11 @@ class AgentsApi:
     @validate_call
     def add_custom_agent_tool_with_http_info(
         self,
-        tool_type: StrictStr,
-        tool_args: StrictStr,
-        file: Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]] = None,
+        tool_type: Annotated[StrictStr, Field(description="The type of custom tool being added: - local_mcp: Model Context Protocol server running locally - remote_mcp: Model Context Protocol server running remotely - browser_action: Custom browser automation actions - general_code: General purpose code execution tools ")],
+        tool_args: Annotated[StrictStr, Field(description="JSON string containing tool-specific arguments. The structure varies by tool_type:  For remote_mcp: {   \\\"mcp_config_json\\\": \\\"JSON string with MCP server configuration\\\",   \\\"enable_by_default\\\": true/false (optional, defaults to true) }  For local_mcp, browser_action, and general_code: {   \\\"tool_name\\\": \\\"string (optional, defaults to filename without extension)\\\",   \\\"description\\\": \\\"string (optional, tool description)\\\",   \\\"enable_by_default\\\": true/false (optional, defaults to true),   \\\"should_unzip\\\": true/false (optional, for general_code .zip files only),   \\\"tool_usage_mode\\\": [\\\"runner\\\", \\\"creator\\\"] (optional list of strings) } ")],
+        file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The tool file to upload. Requirements vary by tool_type: - local_mcp: .zip file containing MCP server code - remote_mcp: Optional .json file with MCP configuration - browser_action: .py file (must start with 'browser_') or .zip containing browser action scripts - general_code: .py or .zip file with custom code ")] = None,
         custom_tool_path: Optional[StrictStr] = None,
-        filename: Optional[StrictStr] = None,
+        filename: Annotated[Optional[StrictStr], Field(description="Optional filename to use when storing the uploaded file")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -160,15 +160,15 @@ class AgentsApi:
 
         Add Custom Agent Tools
 
-        :param tool_type: (required)
+        :param tool_type: The type of custom tool being added: - local_mcp: Model Context Protocol server running locally - remote_mcp: Model Context Protocol server running remotely - browser_action: Custom browser automation actions - general_code: General purpose code execution tools  (required)
         :type tool_type: str
-        :param tool_args: (required)
+        :param tool_args: JSON string containing tool-specific arguments. The structure varies by tool_type:  For remote_mcp: {   \\\"mcp_config_json\\\": \\\"JSON string with MCP server configuration\\\",   \\\"enable_by_default\\\": true/false (optional, defaults to true) }  For local_mcp, browser_action, and general_code: {   \\\"tool_name\\\": \\\"string (optional, defaults to filename without extension)\\\",   \\\"description\\\": \\\"string (optional, tool description)\\\",   \\\"enable_by_default\\\": true/false (optional, defaults to true),   \\\"should_unzip\\\": true/false (optional, for general_code .zip files only),   \\\"tool_usage_mode\\\": [\\\"runner\\\", \\\"creator\\\"] (optional list of strings) }  (required)
         :type tool_args: str
-        :param file:
+        :param file: The tool file to upload. Requirements vary by tool_type: - local_mcp: .zip file containing MCP server code - remote_mcp: Optional .json file with MCP configuration - browser_action: .py file (must start with 'browser_') or .zip containing browser action scripts - general_code: .py or .zip file with custom code 
         :type file: bytearray
         :param custom_tool_path:
         :type custom_tool_path: str
-        :param filename:
+        :param filename: Optional filename to use when storing the uploaded file
         :type filename: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -222,11 +222,11 @@ class AgentsApi:
     @validate_call
     def add_custom_agent_tool_without_preload_content(
         self,
-        tool_type: StrictStr,
-        tool_args: StrictStr,
-        file: Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]] = None,
+        tool_type: Annotated[StrictStr, Field(description="The type of custom tool being added: - local_mcp: Model Context Protocol server running locally - remote_mcp: Model Context Protocol server running remotely - browser_action: Custom browser automation actions - general_code: General purpose code execution tools ")],
+        tool_args: Annotated[StrictStr, Field(description="JSON string containing tool-specific arguments. The structure varies by tool_type:  For remote_mcp: {   \\\"mcp_config_json\\\": \\\"JSON string with MCP server configuration\\\",   \\\"enable_by_default\\\": true/false (optional, defaults to true) }  For local_mcp, browser_action, and general_code: {   \\\"tool_name\\\": \\\"string (optional, defaults to filename without extension)\\\",   \\\"description\\\": \\\"string (optional, tool description)\\\",   \\\"enable_by_default\\\": true/false (optional, defaults to true),   \\\"should_unzip\\\": true/false (optional, for general_code .zip files only),   \\\"tool_usage_mode\\\": [\\\"runner\\\", \\\"creator\\\"] (optional list of strings) } ")],
+        file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The tool file to upload. Requirements vary by tool_type: - local_mcp: .zip file containing MCP server code - remote_mcp: Optional .json file with MCP configuration - browser_action: .py file (must start with 'browser_') or .zip containing browser action scripts - general_code: .py or .zip file with custom code ")] = None,
         custom_tool_path: Optional[StrictStr] = None,
-        filename: Optional[StrictStr] = None,
+        filename: Annotated[Optional[StrictStr], Field(description="Optional filename to use when storing the uploaded file")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -244,15 +244,15 @@ class AgentsApi:
 
         Add Custom Agent Tools
 
-        :param tool_type: (required)
+        :param tool_type: The type of custom tool being added: - local_mcp: Model Context Protocol server running locally - remote_mcp: Model Context Protocol server running remotely - browser_action: Custom browser automation actions - general_code: General purpose code execution tools  (required)
         :type tool_type: str
-        :param tool_args: (required)
+        :param tool_args: JSON string containing tool-specific arguments. The structure varies by tool_type:  For remote_mcp: {   \\\"mcp_config_json\\\": \\\"JSON string with MCP server configuration\\\",   \\\"enable_by_default\\\": true/false (optional, defaults to true) }  For local_mcp, browser_action, and general_code: {   \\\"tool_name\\\": \\\"string (optional, defaults to filename without extension)\\\",   \\\"description\\\": \\\"string (optional, tool description)\\\",   \\\"enable_by_default\\\": true/false (optional, defaults to true),   \\\"should_unzip\\\": true/false (optional, for general_code .zip files only),   \\\"tool_usage_mode\\\": [\\\"runner\\\", \\\"creator\\\"] (optional list of strings) }  (required)
         :type tool_args: str
-        :param file:
+        :param file: The tool file to upload. Requirements vary by tool_type: - local_mcp: .zip file containing MCP server code - remote_mcp: Optional .json file with MCP configuration - browser_action: .py file (must start with 'browser_') or .zip containing browser action scripts - general_code: .py or .zip file with custom code 
         :type file: bytearray
         :param custom_tool_path:
         :type custom_tool_path: str
-        :param filename:
+        :param filename: Optional filename to use when storing the uploaded file
         :type filename: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request