opik 1.6.4__py3-none-any.whl → 1.9.71__py3-none-any.whl

opik/api_objects/opik_client.py

@@ -2,10 +2,32 @@ import atexit
 import datetime
 import functools
 import logging
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, TypeVar, Union, Literal, cast
 
 import httpx
 
+from . import (
+    constants,
+    dataset,
+    experiment,
+    optimization,
+    helpers,
+    opik_query_language,
+    search_helpers,
+    span,
+    trace,
+)
+from .attachment import Attachment
+from .attachment import client as attachment_client
+from .attachment import converters as attachment_converters
+from .dataset import rest_operations as dataset_rest_operations
+from .experiment import experiments_client
+from .experiment import helpers as experiment_helpers
+from .experiment import rest_operations as experiment_rest_operations
+from . import prompt as prompt_module
+from .prompt import client as prompt_client
+from .threads import threads_client
+from .trace import migration as trace_migration, trace_client
 from .. import (
     config,
     datetime_helpers,
@@ -16,31 +38,35 @@ from .. import (
     rest_client_configurator,
     url_helpers,
 )
-from ..message_processing import messages, streamer_constructors
+from ..message_processing import (
+    messages,
+    streamer_constructors,
+    message_queue,
+)
 from ..message_processing.batching import sequence_splitter
+from ..message_processing.processors import message_processors_chain
 from ..rest_api import client as rest_api_client
 from ..rest_api.core.api_error import ApiError
-from ..rest_api.types import dataset_public, project_public, span_public, trace_public
-from ..types import ErrorInfoDict, FeedbackScoreDict, LLMProvider, SpanType
-from . import (
-    constants,
-    dataset,
-    experiment,
-    helpers,
-    opik_query_language,
-    span,
-    trace,
-    validation_helpers,
+from ..rest_api.types import (
+    dataset_public,
+    project_public,
+    span_public,
+    trace_public,
+    span_filter_public,
+    trace_filter_public,
+)
+from ..types import (
+    BatchFeedbackScoreDict,
+    ErrorInfoDict,
+    FeedbackScoreDict,
+    LLMProvider,
+    SpanType,
 )
-from .dataset import rest_operations as dataset_rest_operations
-from .experiment import helpers as experiment_helpers
-from .experiment import rest_operations as experiment_rest_operations
-from .prompt import Prompt
-from .prompt.client import PromptClient
-from .trace import migration as trace_migration
 
 LOGGER = logging.getLogger(__name__)
 
+T = TypeVar("T")
+
 
 class Opik:
     def __init__(
@@ -87,10 +113,6 @@ class Opik:
         self._use_batching = _use_batching
 
         self._initialize_streamer(
-            base_url=config_.url_override,
-            workers=config_.background_workers,
-            api_key=config_.api_key,
-            check_tls_certificate=config_.check_tls_certificate,
             use_batching=_use_batching,
         )
         atexit.register(self.end, timeout=self._flush_timeout)
@@ -103,31 +125,71 @@ class Opik:
         """
         return self._config.model_copy()
 
+    @property
+    def rest_client(self) -> rest_api_client.OpikApi:
+        """
+        Provides direct access to the underlying REST API client.
+
+        WARNING: This client is not guaranteed to be backward compatible with future SDK versions.
+        While it provides a convenient way to use the current REST API of Opik.
+        However, it's not considered safe to heavily rely on its API as Opik's REST API contracts may change.
+
+        Returns:
+            OpikApi: The REST client used by the Opik client.
+        """
+        return self._rest_client
+
+    @property
+    def project_name(self) -> str:
+        """
+        This property retrieves the name of the project associated with the instance.
+        It is a read-only property.
+
+        Returns:
+            str: The name of the project.
+        """
+        return self._project_name
+
     def _initialize_streamer(
         self,
-        base_url: str,
-        workers: int,
-        api_key: Optional[str],
-        check_tls_certificate: bool,
         use_batching: bool,
     ) -> None:
-        httpx_client_ = httpx_client.get(
+        self._httpx_client = httpx_client.get(
             workspace=self._workspace,
-            api_key=api_key,
-            check_tls_certificate=check_tls_certificate,
+            api_key=self._config.api_key,
+            check_tls_certificate=self._config.check_tls_certificate,
+            compress_json_requests=self._config.enable_json_request_compression,
         )
         self._rest_client = rest_api_client.OpikApi(
-            base_url=base_url,
-            httpx_client=httpx_client_,
+            base_url=self._config.url_override,
+            httpx_client=self._httpx_client,
         )
         self._rest_client._client_wrapper._timeout = (
             httpx.USE_CLIENT_DEFAULT
         )  # See https://github.com/fern-api/fern/issues/5321
         rest_client_configurator.configure(self._rest_client)
+
+        max_queue_size = message_queue.calculate_max_queue_size(
+            maximal_queue_size=self._config.maximal_queue_size,
+            batch_factor=self._config.maximal_queue_size_batch_factor,
+        )
+
+        self.__internal_api__message_processor__ = (
+            message_processors_chain.create_message_processors_chain(
+                rest_client=self._rest_client
+            )
+        )
         self._streamer = streamer_constructors.construct_online_streamer(
-            n_consumers=workers,
+            n_consumers=self._config.background_workers,
             rest_client=self._rest_client,
+            httpx_client=self._httpx_client,
             use_batching=use_batching,
+            use_attachment_extraction=self._config.is_attachment_extraction_active,
+            min_base64_embedded_attachment_size=self._config.min_base64_embedded_attachment_size,
+            file_upload_worker_count=self._config.file_upload_background_workers,
+            max_queue_size=max_queue_size,
+            message_processor=self.__internal_api__message_processor__,
+            url_override=self._config.url_override,
         )
 
     def _display_trace_url(self, trace_id: str, project_name: str) -> None:
@@ -173,13 +235,14 @@ class Opik:
         project_name: Optional[str] = None,
         error_info: Optional[ErrorInfoDict] = None,
         thread_id: Optional[str] = None,
+        attachments: Optional[List[Attachment]] = None,
         **ignored_kwargs: Any,
     ) -> trace.Trace:
         """
         Create and log a new trace.
 
         Args:
-            id: The unique identifier for the trace, if not provided a new ID will be generated. Must be a valid [UUIDv7](https://uuid7.com/) ID.
+            id: The unique identifier for the trace, if not provided, a new ID will be generated. Must be a valid [UUIDv7](https://uuid7.com/) ID.
             name: The name of the trace.
             start_time: The start time of the trace. If not provided, the current local time will be used.
             end_time: The end time of the trace.
@@ -193,6 +256,7 @@ class Opik:
             error_info: The dictionary with error information (typically used when the trace function has failed).
             thread_id: Used to group multiple traces into a thread.
                 The identifier is user-defined and has to be unique per project.
+            attachments: The list of attachments to be uploaded to the trace.
 
         Returns:
             trace.Trace: The created trace object.
@@ -201,6 +265,7 @@ class Opik:
         start_time = (
             start_time if start_time is not None else datetime_helpers.local_timestamp()
         )
+        last_updated_at = datetime_helpers.local_timestamp()
 
         if project_name is None:
             project_name = self._project_name
@@ -217,6 +282,7 @@ class Opik:
             tags=tags,
             error_info=error_info,
             thread_id=thread_id,
+            last_updated_at=last_updated_at,
         )
         self._streamer.put(create_trace_message)
         self._display_trace_url(trace_id=id, project_name=project_name)
@@ -225,12 +291,27 @@ class Opik:
             for feedback_score in feedback_scores:
                 feedback_score["id"] = id
 
-            self.log_traces_feedback_scores(feedback_scores, project_name)
+            self.log_traces_feedback_scores(
+                cast(List[BatchFeedbackScoreDict], feedback_scores), project_name
+            )
+
+        if attachments is not None:
+            for attachment_data in attachments:
+                self._streamer.put(
+                    attachment_converters.attachment_to_message(
+                        attachment_data=attachment_data,
+                        entity_type="trace",
+                        entity_id=id,
+                        project_name=project_name,
+                        url_override=self._config.url_override,
+                    )
+                )
 
         return trace.Trace(
             id=id,
             message_streamer=self._streamer,
             project_name=project_name,
+            url_override=self._config.url_override,
         )
 
     def copy_traces(
@@ -248,7 +329,7 @@ class Opik:
 
         Note: This method is not optimized for large projects, if you run into any issues please raise
         an issue on GitHub. In addition, be aware that deleting traces that are linked to experiments
-        will lead to inconsistancies in the UI.
+        will lead to inconsistencies in the UI.
 
         Args:
             project_name: The name of the project to copy traces from.
@@ -287,10 +368,10 @@ class Opik:
         )
 
         for trace_data_ in new_trace_data:
-            self.trace(**trace_data_.__dict__)
+            self.trace(**trace_data_.as_parameters)
 
         for span_data_ in new_span_data:
-            self.span(**span_data_.__dict__)
+            self.span(**span_data_.as_parameters)
 
         if delete_original_project:
             trace_ids = [trace_.id for trace_ in trace_data]
@@ -320,6 +401,7 @@ class Opik:
         provider: Optional[Union[str, LLMProvider]] = None,
         error_info: Optional[ErrorInfoDict] = None,
         total_cost: Optional[float] = None,
+        attachments: Optional[List[Attachment]] = None,
     ) -> span.Span:
         """
         Create and log a new span.
@@ -336,19 +418,20 @@ class Opik:
             input: The input data for the span. This can be any valid JSON serializable object.
             output: The output data for the span. This can be any valid JSON serializable object.
             tags: Tags associated with the span.
-            feedback_scores: The list of feedback score dicts associated with the span. Dicts don't require to have an `id` value.
-            project_name: The name of the project. If not set, the project name which was configured when Opik instance
+            feedback_scores: The list of feedback score dicts associated with the span. Dicts don't require having an `id` value.
+            project_name: The name of the project. If not set, the project name which was configured when the Opik instance
                 was created will be used.
-            usage: Usage data for the span. In order for input, output and total tokens to be visible in the UI,
-                the usage must contain OpenAI-formatted keys (they can be passed additionaly to original usage on the top level of the dict):  prompt_tokens, completion_tokens and total_tokens.
+            usage: Usage data for the span. In order for input, output, and total tokens to be visible in the UI,
+                the usage must contain OpenAI-formatted keys (they can be passed additionally to the original usage on the top level of the dict): prompt_tokens, completion_tokens, and total_tokens.
                 If OpenAI-formatted keys were not found, Opik will try to calculate them automatically if the usage
                 format is recognized (you can see which provider's formats are recognized in opik.LLMProvider enum), but it is not guaranteed.
             model: The name of LLM (in this case `type` parameter should be == `llm`)
             provider: The provider of LLM. You can find providers officially supported by Opik for cost tracking
-                in `opik.LLMProvider` enum. If your provider is not here, please open an issue in our github - https://github.com/comet-ml/opik.
-                If your provider not in the list, you can still specify it but the cost tracking will not be available
+                in `opik.LLMProvider` enum. If your provider is not here, please open an issue in our GitHub - https://github.com/comet-ml/opik.
+                If your provider is not in the list, you can still specify it, but the cost tracking will not be available
             error_info: The dictionary with error information (typically used when the span function has failed).
             total_cost: The cost of the span in USD. This value takes priority over the cost calculated by Opik from the usage.
+            attachments: The list of attachments to be uploaded to the span.
 
         Returns:
             span.Span: The created span object.
@@ -358,15 +441,6 @@ class Opik:
             start_time if start_time is not None else datetime_helpers.local_timestamp()
         )
 
-        backend_compatible_usage = validation_helpers.validate_and_parse_usage(
-            usage=usage,
-            logger=LOGGER,
-            provider=provider,
-        )
-
-        if backend_compatible_usage is not None:
-            metadata = helpers.add_usage_to_metadata(usage=usage, metadata=metadata)
-
         if project_name is None:
             project_name = self._project_name
 
@@ -386,13 +460,24 @@ class Opik:
                 tags=tags,
                 error_info=error_info,
                 thread_id=None,
+                last_updated_at=datetime_helpers.local_timestamp(),
             )
             self._streamer.put(create_trace_message)
 
-        create_span_message = messages.CreateSpanMessage(
-            span_id=id,
+        if feedback_scores is not None:
+            for feedback_score in feedback_scores:
+                feedback_score["id"] = id
+
+            self.log_spans_feedback_scores(
+                cast(List[BatchFeedbackScoreDict], feedback_scores), project_name
+            )
+
+        return span.span_client.create_span(
             trace_id=trace_id,
             project_name=project_name,
+            url_override=self._config.url_override,
+            message_streamer=self._streamer,
+            span_id=id,
             parent_span_id=parent_span_id,
             name=name,
             type=type,
@@ -402,60 +487,194 @@ class Opik:
             output=output,
             metadata=metadata,
             tags=tags,
-            usage=backend_compatible_usage,
+            usage=usage,
             model=model,
             provider=provider,
             error_info=error_info,
             total_cost=total_cost,
+            attachments=attachments,
         )
-        self._streamer.put(create_span_message)
 
-        if feedback_scores is not None:
-            for feedback_score in feedback_scores:
-                feedback_score["id"] = id
+    def update_span(
+        self,
+        id: str,
+        trace_id: str,
+        parent_span_id: Optional[str],
+        project_name: str,
+        end_time: Optional[datetime.datetime] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        input: Optional[Dict[str, Any]] = None,
+        output: Optional[Dict[str, Any]] = None,
+        tags: Optional[List[str]] = None,
+        usage: Optional[Union[Dict[str, Any], llm_usage.OpikUsage]] = None,
+        model: Optional[str] = None,
+        provider: Optional[Union[LLMProvider, str]] = None,
+        error_info: Optional[ErrorInfoDict] = None,
+        total_cost: Optional[float] = None,
+        attachments: Optional[List[Attachment]] = None,
+    ) -> None:
+        """
+        Update the attributes of an existing span.
 
-            self.log_spans_feedback_scores(feedback_scores, project_name)
+        This method should only be used after the span has been fully created and stored.
+        If called before or immediately after span creation, the update may silently fail or result in incorrect data.
 
-        return span.Span(
+        This method uses four parameters to identify the span:
+            - `id`
+            - `trace_id`
+            - `parent_span_id`
+            - `project_name`
+
+        These parameters **must match exactly** the values used when the span was created.
+        If any of them are incorrect, the update may not apply and no error will be raised.
+
+        All other parameters are optional and will update the corresponding fields in the span.
+        If a parameter is not provided, the existing value will remain unchanged.
+
+        Args:
+            id: The unique identifier for the span to update.
+            trace_id: The unique identifier for the trace to which the span belongs.
+            parent_span_id: The unique identifier for the parent span.
+            project_name: The project name to which the span belongs.
+            end_time: The new end time of the span.
+            metadata: The new metadata to be associated with the span.
+            input: The new input data for the span.
+            output: The new output data for the span.
+            tags: A new list of tags to be associated with the span.
+            usage: The new usage data for the span. In order for input, output and total tokens to be visible in the UI,
+                the usage must contain OpenAI-formatted keys (they can be passed additionaly to original usage on the top level of the dict):  prompt_tokens, completion_tokens and total_tokens.
+                If OpenAI-formatted keys were not found, Opik will try to calculate them automatically if the usage
+                format is recognized (you can see which provider's formats are recognized in opik.LLMProvider enum), but it is not guaranteed.
+            model: The new name of LLM.
+            provider: The new provider of LLM. You can find providers officially supported by Opik for cost tracking
+                in `opik.LLMProvider` enum. If your provider is not here, please open an issue in our github - https://github.com/comet-ml/opik.
+                If your provider not in the list, you can still specify it but the cost tracking will not be available
+            error_info: The new dictionary with error information (typically used when the span function has failed).
+            total_cost: The new cost of the span in USD. This value takes priority over the cost calculated by Opik from the usage.
+            attachments: The new list of attachments to be uploaded to the span.
+
+        Returns:
+            None
+        """
+        span.span_client.update_span(
             id=id,
+            trace_id=trace_id,
             parent_span_id=parent_span_id,
+            url_override=self._config.url_override,
+            message_streamer=self._streamer,
+            project_name=project_name,
+            end_time=end_time,
+            metadata=metadata,
+            input=input,
+            output=output,
+            tags=tags,
+            usage=usage,
+            model=model,
+            provider=provider,
+            error_info=error_info,
+            total_cost=total_cost,
+            attachments=attachments,
+        )
+
+    def update_trace(
+        self,
+        trace_id: str,
+        project_name: str,
+        end_time: Optional[datetime.datetime] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        input: Optional[Dict[str, Any]] = None,
+        output: Optional[Dict[str, Any]] = None,
+        tags: Optional[List[Any]] = None,
+        error_info: Optional[ErrorInfoDict] = None,
+        thread_id: Optional[str] = None,
+    ) -> None:
+        """
+        Update the trace attributes.
+
+        This method should only be used after the trace has been fully created and stored.
+        If called before or immediately after trace creation, the update may silently fail or result in incorrect data.
+
+        This method uses two parameters to identify the trace:
+            - `trace_id`
+            - `project_name`
+
+        These parameters **must match exactly** the values used when the trace was created.
+        If any of them are incorrect, the update may not apply and no error will be raised.
+
+        All other parameters are optional and will update the corresponding fields in the trace.
+        If a parameter is not provided, the existing value will remain unchanged.
+
+        Args:
+            trace_id: The unique identifier for the trace.
+            project_name: The project name to which the trace belongs.
+            end_time: The end time of the trace.
+            metadata: Additional metadata to be associated with the trace.
+            input: The input data for the trace.
+            output: The output data for the trace.
+            tags: A list of tags to be associated with the trace.
+            error_info: The dictionary with error information (typically used when the trace function has failed).
+            thread_id: Used to group multiple traces into a thread.
+                The identifier is user-defined and has to be unique per project.
+
+        Returns:
+            None
+        """
+        if not trace_id or not project_name:
+            raise ValueError(
+                "trace_id and project_name must be provided and can not be None or empty, "
+                f"trace_id: {trace_id}, project_name: {project_name}"
+            )
+
+        trace_client.update_trace(
             trace_id=trace_id,
             project_name=project_name,
             message_streamer=self._streamer,
+            end_time=end_time,
+            metadata=metadata,
+            input=input,
+            output=output,
+            tags=tags,
+            error_info=error_info,
+            thread_id=thread_id,
         )
 
     def log_spans_feedback_scores(
-        self, scores: List[FeedbackScoreDict], project_name: Optional[str] = None
+        self, scores: List[BatchFeedbackScoreDict], project_name: Optional[str] = None
     ) -> None:
         """
         Log feedback scores for spans.
 
         Args:
-            scores (List[FeedbackScoreDict]): A list of feedback score dictionaries.
+            scores (List[BatchFeedbackScoreDict]): A list of feedback score dictionaries.
                 Specifying a span id via `id` key for each score is mandatory.
             project_name: The name of the project in which the spans are logged. If not set, the project name
-                which was configured when Opik instance was created will be used.
+                which was configured when the Opik instance was created will be used.
+                Deprecated: use `project_name` in the feedback score dictionary that's listed in the `scores` parameter.
 
         Returns:
             None
-        """
-        valid_scores = [
-            score
-            for score in scores
-            if validation_helpers.validate_feedback_score(score, LOGGER) is not None
-        ]
 
-        if len(valid_scores) == 0:
-            return None
-
-        score_messages = [
-            messages.FeedbackScoreMessage(
-                source=constants.FEEDBACK_SCORE_SOURCE_SDK,
-                project_name=project_name or self._project_name,
-                **score_dict,
+        Example:
+            >>> from opik import Opik
+            >>> client = Opik()
+            >>> # Batch logging across multiple projects
+            >>> scores = [
+            >>>     {"id": span1_id, "name": "accuracy", "value": 0.95, "project_name": "project-A"},
+            >>>     {"id": span2_id, "name": "accuracy", "value": 0.88, "project_name": "project-B"},
+            >>> ]
+            >>> client.log_spans_feedback_scores(scores=scores)
+        """
+        score_messages = helpers.parse_feedback_score_messages(
+            scores=scores,
+            project_name=project_name or self.project_name,
+            parsed_item_class=messages.FeedbackScoreMessage,
+            logger=LOGGER,
+        )
+        if score_messages is None:
+            LOGGER.error(
+                f"No valid spans feedback scores to log from provided ones: {scores}"
             )
-            for score_dict in valid_scores
-        ]
+            return
 
         for batch in sequence_splitter.split_into_batches(
             score_messages,
@@ -469,47 +688,84 @@ class Opik:
             self._streamer.put(add_span_feedback_scores_batch_message)
 
     def log_traces_feedback_scores(
-        self, scores: List[FeedbackScoreDict], project_name: Optional[str] = None
+        self, scores: List[BatchFeedbackScoreDict], project_name: Optional[str] = None
     ) -> None:
         """
         Log feedback scores for traces.
 
         Args:
-            scores (List[FeedbackScoreDict]): A list of feedback score dictionaries.
+            scores (List[BatchFeedbackScoreDict]): A list of feedback score dictionaries.
                 Specifying a trace id via `id` key for each score is mandatory.
             project_name: The name of the project in which the traces are logged. If not set, the project name
-                which was configured when Opik instance was created will be used.
+                which was configured when the Opik instance was created will be used.
+                Deprecated: use `project_name` in the feedback score dictionary that's listed in the `scores` parameter.
 
         Returns:
             None
-        """
-        valid_scores = [
-            score
-            for score in scores
-            if validation_helpers.validate_feedback_score(score, LOGGER) is not None
-        ]
 
-        if len(valid_scores) == 0:
-            return None
+        Example:
+            >>> from opik import Opik
+            >>> client = Opik()
+            >>> # Batch logging across multiple projects
+            >>> scores = [
+            >>>     {"id": trace1_id, "name": "accuracy", "value": 0.95, "project_name": "project-A"},
+            >>>     {"id": trace2_id, "name": "accuracy", "value": 0.88, "project_name": "project-B"},
+            >>> ]
+            >>> client.log_traces_feedback_scores(scores=scores)
+        """
+        score_messages = helpers.parse_feedback_score_messages(
+            scores=scores,
+            project_name=project_name or self.project_name,
+            parsed_item_class=messages.FeedbackScoreMessage,
+            logger=LOGGER,
+        )
 
-        score_messages = [
-            messages.FeedbackScoreMessage(
-                source=constants.FEEDBACK_SCORE_SOURCE_SDK,
-                project_name=project_name or self._project_name,
-                **score_dict,
+        if score_messages is None:
+            LOGGER.error(
+                f"No valid traces feedback scores to log from provided ones: {scores}"
             )
-            for score_dict in valid_scores
-        ]
+            return
+
         for batch in sequence_splitter.split_into_batches(
             score_messages,
             max_payload_size_MB=config.MAX_BATCH_SIZE_MB,
             max_length=constants.FEEDBACK_SCORES_MAX_BATCH_SIZE,
         ):
-            add_span_feedback_scores_batch_message = (
+            add_trace_feedback_scores_batch_message = (
                 messages.AddTraceFeedbackScoresBatchMessage(batch=batch)
             )
 
-            self._streamer.put(add_span_feedback_scores_batch_message)
+            self._streamer.put(add_trace_feedback_scores_batch_message)
+
+    def log_threads_feedback_scores(
+        self, scores: List[BatchFeedbackScoreDict], project_name: Optional[str] = None
+    ) -> None:
+        """
+        Log feedback scores for threads.
+
+        Args:
+            scores (List[BatchFeedbackScoreDict]): A list of feedback score dictionaries.
+                Specifying a thread id via `id` key for each score is mandatory.
+            project_name: The name of the project in which the threads are logged. If not set, the project name
+                which was configured when the Opik instance was created will be used.
+                Deprecated: use `project_name` in the feedback score dictionary that's listed in the `scores` parameter.
+
+        Returns:
+            None
+
+        Example:
+            >>> from opik import Opik
+            >>> client = Opik()
+            >>> # Batch logging across multiple projects
+            >>> scores = [
+            >>>     {"id": "thread_123", "name": "user_satisfaction", "value": 0.85, "project_name": "project-A"},
+            >>>     {"id": "thread_456", "name": "user_satisfaction", "value": 0.92, "project_name": "project-B"},
+            >>> ]
+            >>> client.log_threads_feedback_scores(scores=scores)
+        """
+        self.get_threads_client().log_threads_feedback_scores(
+            scores=scores, project_name=project_name
+        )
 
     def delete_trace_feedback_score(self, trace_id: str, name: str) -> None:
         """
@@ -611,8 +867,13 @@ class Opik:
             self._rest_client, dataset_name
         )
 
+        experiments_client = self.get_experiments_client()
         experiments = dataset_rest_operations.get_dataset_experiments(
-            self._rest_client, dataset_id, max_results
+            rest_client=self._rest_client,
+            dataset_id=dataset_id,
+            max_results=max_results,
+            streamer=self._streamer,
+            experiments_client=experiments_client,
         )
 
         return experiments
@@ -676,8 +937,10 @@ class Opik:
         dataset_name: str,
         name: Optional[str] = None,
         experiment_config: Optional[Dict[str, Any]] = None,
-        prompt: Optional[Prompt] = None,
-        prompts: Optional[List[Prompt]] = None,
+        prompt: Optional[prompt_module.base_prompt.BasePrompt] = None,
+        prompts: Optional[List[prompt_module.base_prompt.BasePrompt]] = None,
+        type: Literal["regular", "trial", "mini-batch"] = "regular",
+        optimization_id: Optional[str] = None,
     ) -> experiment.Experiment:
         """
         Creates a new experiment using the given dataset name and optional parameters.
@@ -688,6 +951,9 @@ class Opik:
             experiment_config: Optional experiment configuration parameters. Must be a dictionary if provided.
             prompt: Prompt object to associate with the experiment. Deprecated, use `prompts` argument instead.
             prompts: List of Prompt objects to associate with the experiment.
+            type: The type of the experiment. Can be "regular", "trial", or "mini-batch".
+                Defaults to "regular". "trial" and "mini-batch" are only relevant for prompt optimization experiments.
+            optimization_id: Optional ID of the optimization associated with the experiment.
 
         Returns:
             experiment.Experiment: The newly created experiment object.
@@ -710,6 +976,8 @@ class Opik:
             id=id,
             metadata=metadata,
             prompt_versions=prompt_versions,
+            type=type,
+            optimization_id=optimization_id,
         )
 
         experiment_ = experiment.Experiment(
@@ -717,11 +985,49 @@ class Opik:
             name=name,
             dataset_name=dataset_name,
             rest_client=self._rest_client,
+            streamer=self._streamer,
+            experiments_client=self.get_experiments_client(),
             prompts=checked_prompts,
         )
 
         return experiment_
 
+    def update_experiment(
+        self,
+        id: str,
+        name: Optional[str] = None,
+        experiment_config: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """
+        Update an experiment's name and/or configuration.
+
+        Args:
+            id: The experiment ID.
+            name: The new name for the experiment. If None, the name will not be updated.
+            experiment_config: The new configuration for the experiment. If None, the configuration will not be updated.
+
+        Raises:
+            ValueError: if id is None or empty, or if both name and experiment_config are None
+        """
+        if not id:
+            raise ValueError(
+                f"id must be provided and can not be None or empty, id: {id}"
+            )
+
+        if name is None and experiment_config is None:
+            raise ValueError(
+                "At least one of 'name' or 'experiment_config' must be provided"
+            )
+
+        # Only include parameters that are provided to avoid clearing fields
+        request_params: Dict[str, Any] = {}
+        if name is not None:
+            request_params["name"] = name
+        if experiment_config is not None:
+            request_params["metadata"] = experiment_config
+
+        self._rest_client.experiments.update_experiment(id, **request_params)
+
     def get_experiment_by_name(self, name: str) -> experiment.Experiment:
         """
         Returns an existing experiment by its name.
@@ -741,18 +1047,20 @@ class Opik:
 
         return experiment.Experiment(
             id=experiment_public.id,
-            name=name,
+            name=experiment_public.name,
             dataset_name=experiment_public.dataset_name,
             rest_client=self._rest_client,
-            # TODO: add prompt if exists
+            streamer=self._streamer,
+            experiments_client=self.get_experiments_client(),
         )
 
     def get_experiments_by_name(self, name: str) -> List[experiment.Experiment]:
         """
-        Returns an existing experiments by its name.
+        Returns a list of existing experiments containing the given string in their name.
+        Search is case-insensitive.
 
         Args:
-            name: The name of the experiment(s).
+            name: The string to search for in the experiment names.
 
         Returns:
             List[experiment.Experiment]: List of existing experiments.
@@ -765,9 +1073,11 @@ class Opik:
         for public_experiment in experiments_public:
             experiment_ = experiment.Experiment(
                 id=public_experiment.id,
+                name=public_experiment.name,
                 dataset_name=public_experiment.dataset_name,
-                name=name,
                 rest_client=self._rest_client,
+                streamer=self._streamer,
+                experiments_client=self.get_experiments_client(),
             )
             result.append(experiment_)
 
@@ -799,7 +1109,8 @@ class Opik:
             name=experiment_public.name,
             dataset_name=experiment_public.dataset_name,
             rest_client=self._rest_client,
-            # TODO: add prompt if exists
+            streamer=self._streamer,
+            experiments_client=self.get_experiments_client(),
         )
 
     def end(self, timeout: Optional[int] = None) -> None:
@@ -815,7 +1126,7 @@ class Opik:
         timeout = timeout if timeout is not None else self._flush_timeout
         self._streamer.close(timeout)
 
-    def flush(self, timeout: Optional[int] = None) -> None:
+    def flush(self, timeout: Optional[int] = None) -> bool:
         """
         Flush the streamer to ensure all messages are sent.
 
@@ -823,10 +1134,10 @@ class Opik:
             timeout (Optional[int]): The timeout for flushing the streamer. Once the timeout is reached, the flush method will return regardless of whether all messages have been sent.
 
         Returns:
-            None
+            True if all messages have been sent within specified timeout, False otherwise.
         """
         timeout = timeout if timeout is not None else self._flush_timeout
-        self._streamer.flush(timeout)
+        return self._streamer.flush(timeout)
 
     def search_traces(
         self,
@@ -834,39 +1145,90 @@ class Opik:
         filter_string: Optional[str] = None,
         max_results: int = 1000,
         truncate: bool = True,
+        wait_for_at_least: Optional[int] = None,
+        wait_for_timeout: int = httpx_client.READ_TIMEOUT_SECONDS,
     ) -> List[trace_public.TracePublic]:
         """
-        Search for traces in the given project.
+        Search for traces in the given project. Optionally, you can wait for at least a certain number of traces
+        to be found before returning within the specified timeout. If wait_for_at_least number of traces are not found
+        within the specified timeout, an exception will be raised.
 
         Args:
             project_name: The name of the project to search traces in. If not provided, will search across the project name configured when the Client was created which defaults to the `Default Project`.
-            filter_string: A filter string to narrow down the search. If not provided, all traces in the project will be returned up to the limit.
+            filter_string: A filter string to narrow down the search using Opik Query Language (OQL).
+                The format is: "<COLUMN> <OPERATOR> <VALUE> [AND <COLUMN> <OPERATOR> <VALUE>]*"
+
+                Supported columns include:
+                - `id`, `name`, `created_by`, `thread_id`, `type`, `model`, `provider`: String fields with full operator support
+                - `status`: String field (=, contains, not_contains only)
+                - `start_time`, `end_time`: DateTime fields (use ISO 8601 format, e.g., "2024-01-01T00:00:00Z")
+                - `input`, `output`: String fields for content (=, contains, not_contains only)
+                - `metadata`: Dictionary field (use dot notation, e.g., "metadata.model")
+                - `feedback_scores`: Numeric field (use dot notation, e.g., "feedback_scores.accuracy")
+                - `tags`: List field (use "contains" operator only)
+                - `usage.total_tokens`, `usage.prompt_tokens`, `usage.completion_tokens`: Numeric usage fields
+                - `duration`, `number_of_messages`, `total_estimated_cost`: Numeric fields
+
+                Supported operators by column:
+                - `id`, `name`, `created_by`, `thread_id`, `type`, `model`, `provider`: =, !=, contains, not_contains, starts_with, ends_with, >, <
+                - `status`: =, contains, not_contains
+                - `start_time`, `end_time`: =, >, <, >=, <=
+                - `input`, `output`: =, contains, not_contains
+                - `metadata`: =, contains, >, <
+                - `feedback_scores`: =, >, <, >=, <=, is_empty, is_not_empty
+                - `tags`: contains (only)
+                - `usage.total_tokens`, `usage.prompt_tokens`, `usage.completion_tokens`, `duration`, `number_of_messages`, `total_estimated_cost`: =, !=, >, <, >=, <=
+
+                Examples:
+                - `start_time >= "2024-01-01T00:00:00Z"` - Filter by start date
+                - `start_time > "2024-01-01T00:00:00Z" AND start_time < "2024-02-01T00:00:00Z"` - Date range
+                - `input contains "question"` - Filter by input content
+                - `usage.total_tokens > 1000` - Filter by token usage
+                - `feedback_scores.accuracy > 0.8` - Filter by feedback score
+                - `feedback_scores.my_metric is_empty` - Filter traces with empty feedback score
+                - `feedback_scores.my_metric is_not_empty` - Filter traces with non-empty feedback score
+                - `tags contains "production"` - Filter by tag
+                - `metadata.model = "gpt-4"` - Filter by metadata field
+                - `thread_id = "thread_123"` - Filter by thread ID
+
+                If not provided, all traces in the project will be returned up to the limit.
             max_results: The maximum number of traces to return.
-            truncate: Whether to truncate image data stored in input, output or metadata
+            truncate: Whether to truncate image data stored in input, output, or metadata
+            wait_for_at_least: The minimum number of traces to wait for before returning.
+            wait_for_timeout: The timeout for waiting for traces.
+
+        Raises:
+            exceptions.SearchTimeoutError if wait_for_at_least traces are not found within the specified timeout.
         """
+        filters_ = helpers.parse_filter_expressions(
+            filter_string, parsed_item_class=trace_filter_public.TraceFilterPublic
+        )
 
-        page_size = 100
-        traces: List[trace_public.TracePublic] = []
+        search_functor = functools.partial(
+            search_helpers.search_traces_with_filters,
+            rest_client=self._rest_client,
+            project_name=project_name or self._project_name,
+            filters=filters_,
+            max_results=max_results,
+            truncate=truncate,
+        )
 
-        filters = opik_query_language.OpikQueryLanguage(filter_string).parsed_filters
+        if wait_for_at_least is None:
+            return search_functor()
 
-        page = 1
-        while len(traces) < max_results:
-            page_traces = self._rest_client.traces.get_traces_by_project(
-                project_name=project_name or self._project_name,
-                filters=filters,
-                page=page,
-                size=page_size,
-                truncate=truncate,
+        # do synchronization with backend if wait_for_at_least is provided until a specific number of traces are found
+        result = search_helpers.search_and_wait_for_done(
+            search_functor=search_functor,
+            wait_for_at_least=wait_for_at_least,
+            wait_for_timeout=wait_for_timeout,
+            sleep_time=5,
+        )
+        if len(result) < wait_for_at_least:
+            raise exceptions.SearchTimeoutError(
+                f"Timeout after {wait_for_timeout} seconds: expected {wait_for_at_least} traces, but only {len(result)} were found."
             )
 
-            if len(page_traces.content) == 0:
-                break
-
-            traces.extend(page_traces.content)
-            page += 1
-
-        return traces[:max_results]
+        return result
 
     def search_spans(
         self,
@@ -875,41 +1237,93 @@ class Opik:
         filter_string: Optional[str] = None,
         max_results: int = 1000,
         truncate: bool = True,
+        wait_for_at_least: Optional[int] = None,
+        wait_for_timeout: int = httpx_client.READ_TIMEOUT_SECONDS,
     ) -> List[span_public.SpanPublic]:
         """
         Search for spans in the given trace. This allows you to search spans based on the span input, output,
-        metadata, tags, etc or based on the trace ID.
+        metadata, tags, etc. or based on the trace ID. Also, you can wait for at least a certain number of spans
+        to be found before returning within the specified timeout. If wait_for_at_least number of spans are not found
+        within the specified timeout, an exception will be raised.
 
         Args:
             project_name: The name of the project to search spans in. If not provided, will search across the project name configured when the Client was created which defaults to the `Default Project`.
             trace_id: The ID of the trace to search spans in. If provided, the search will be limited to the spans in the given trace.
-            filter_string: A filter string to narrow down the search.
+            filter_string: A filter string to narrow down the search using Opik Query Language (OQL).
+                The format is: "<COLUMN> <OPERATOR> <VALUE> [AND <COLUMN> <OPERATOR> <VALUE>]*"
+
+                Supported columns include:
+                - `id`, `name`, `created_by`, `thread_id`, `type`, `model`, `provider`: String fields with full operator support
+                - `status`: String field (=, contains, not_contains only)
+                - `start_time`, `end_time`: DateTime fields (use ISO 8601 format, e.g., "2024-01-01T00:00:00Z")
+                - `input`, `output`: String fields for content (=, contains, not_contains only)
+                - `metadata`: Dictionary field (use dot notation, e.g., "metadata.model")
+                - `feedback_scores`: Numeric field (use dot notation, e.g., "feedback_scores.accuracy")
+                - `tags`: List field (use "contains" operator only)
+                - `usage.total_tokens`, `usage.prompt_tokens`, `usage.completion_tokens`: Numeric usage fields
+                - `duration`, `number_of_messages`, `total_estimated_cost`: Numeric fields
+
+                Supported operators by column:
+                - `id`, `name`, `created_by`, `thread_id`, `type`, `model`, `provider`: =, !=, contains, not_contains, starts_with, ends_with, >, <
+                - `status`: =, contains, not_contains
+                - `start_time`, `end_time`: =, >, <, >=, <=
+                - `input`, `output`: =, contains, not_contains
+                - `metadata`: =, contains, >, <
+                - `feedback_scores`: =, >, <, >=, <=, is_empty, is_not_empty
+                - `tags`: contains (only)
+                - `usage.total_tokens`, `usage.prompt_tokens`, `usage.completion_tokens`, `duration`, `number_of_messages`, `total_estimated_cost`: =, !=, >, <, >=, <=
+
+                Examples:
+                - `start_time >= "2024-01-01T00:00:00Z"` - Filter by start date
+                - `start_time > "2024-01-01T00:00:00Z" AND start_time < "2024-02-01T00:00:00Z"` - Date range
+                - `input contains "question"` - Filter by input content
+                - `usage.total_tokens > 1000` - Filter by token usage
+                - `feedback_scores.accuracy > 0.8` - Filter by feedback score
+                - `feedback_scores.my_metric is_empty` - Filter spans with empty feedback score
+                - `feedback_scores.my_metric is_not_empty` - Filter spans with non-empty feedback score
+                - `tags contains "production"` - Filter by tag
+                - `metadata.model = "gpt-4"` - Filter by metadata field
+                - `thread_id = "thread_123"` - Filter by thread ID
+
+                If not provided, all spans in the project/trace will be returned up to the limit.
             max_results: The maximum number of spans to return.
-            truncate: Whether to truncate image data stored in input, output or metadata
-        """
-        page_size = 100
-        spans: List[span_public.SpanPublic] = []
+            truncate: Whether to truncate image data stored in input, output, or metadata
+            wait_for_at_least: The minimum number of spans to wait for before returning.
+            wait_for_timeout: The timeout for waiting for spans.
 
-        filters = opik_query_language.OpikQueryLanguage(filter_string).parsed_filters
+        Raises:
+            exceptions.SearchTimeoutError if wait_for_at_least spans are not found within the specified timeout.
+        """
+        filters = helpers.parse_filter_expressions(
+            filter_string, parsed_item_class=span_filter_public.SpanFilterPublic
+        )
 
-        page = 1
-        while len(spans) < max_results:
-            page_spans = self._rest_client.spans.get_spans_by_project(
-                project_name=project_name or self._project_name,
-                trace_id=trace_id,
-                filters=filters,
-                page=page,
-                size=page_size,
-                truncate=truncate,
-            )
+        search_functor = functools.partial(
+            search_helpers.search_spans_with_filters,
+            rest_client=self._rest_client,
+            project_name=project_name or self._project_name,
+            trace_id=trace_id,
+            filters=filters,
+            max_results=max_results,
+            truncate=truncate,
+        )
 
-            if len(page_spans.content) == 0:
-                break
+        if wait_for_at_least is None:
+            return search_functor()
 
-            spans.extend(page_spans.content)
-            page += 1
+        # do synchronization with backend if wait_for_at_least is provided until a specific number of spans are found
+        result = search_helpers.search_and_wait_for_done(
+            search_functor=search_functor,
+            wait_for_at_least=wait_for_at_least,
+            wait_for_timeout=wait_for_timeout,
+            sleep_time=5,
+        )
+        if len(result) < wait_for_at_least:
+            raise exceptions.SearchTimeoutError(
+                f"Timeout after {wait_for_timeout} seconds: expected {wait_for_at_least} spans, but only {len(result)} were found."
+            )
 
-        return spans[:max_results]
+        return result
 
     def get_trace_content(self, id: str) -> trace_public.TracePublic:
         """
@@ -936,7 +1350,7 @@ class Opik:
         Fetches a project by its unique identifier.
 
         Parameters:
-            id (str): project if (uuid).
+            id (str): project id (uuid).
 
         Returns:
             project_public.ProjectPublic: pydantic model object with all the data associated with the project found.
@@ -958,9 +1372,45 @@ class Opik:
             str: URL
         """
 
+        dereferenced_workspace = self._workspace
+        if dereferenced_workspace == config.OPIK_WORKSPACE_DEFAULT_NAME:
+            dereferenced_workspace = (
+                self._rest_client.check.get_workspace_name().workspace_name
+            )
+
         project_name = project_name or self._project_name
+
         return url_helpers.get_project_url_by_workspace(
-            workspace=self._workspace, project_name=project_name
+            workspace=dereferenced_workspace, project_name=project_name
+        )
+
+    def get_threads_client(self) -> threads_client.ThreadsClient:
+        """
+        Creates and provides an instance of the ``ThreadsClient`` tied to the current context.
+
+        The ``ThreadsClient`` can be used to interact with the threads API to manage and interact with conversational threads.
+
+        Returns:
+            ThreadsClient: An instance of ``threads_client.ThreadsClient`` initialized
+            with the current context.
+        """
+        return threads_client.ThreadsClient(self)
+
+    def get_attachment_client(self) -> attachment_client.AttachmentClient:
+        """
+        Creates and provides an instance of the ``AttachmentClient`` tied to the current context.
+
+        The ``AttachmentClient`` can be used to interact with the attachments API to retrieve
+        attachment lists, download attachments, and upload attachments for traces and spans.
+
+        Returns:
+            AttachmentClient: An instance of ``attachment.client.AttachmentClient``
+        """
+        return attachment_client.AttachmentClient(
+            rest_client=self._rest_client,
+            url_override=self._config.url_override,
+            workspace_name=self._workspace,
+            rest_httpx_client=self._httpx_client,
         )
 
     def create_prompt(
@@ -968,55 +1418,303 @@ class Opik:
         name: str,
         prompt: str,
         metadata: Optional[Dict[str, Any]] = None,
-    ) -> Prompt:
+        type: prompt_module.PromptType = prompt_module.PromptType.MUSTACHE,
+    ) -> prompt_module.Prompt:
         """
-        Creates a new prompt with the given name and template.
-        If a prompt with the same name already exists, it will create a new version of the existing prompt if the templates differ.
+        Creates a new text prompt with the given name and template.
+        If a text prompt with the same name already exists, it will create a new version of the existing prompt if the templates differ.
 
         Parameters:
             name: The name of the prompt.
             prompt: The template content of the prompt.
             metadata: Optional metadata to be included in the prompt.
+            type: The template type (MUSTACHE or JINJA2).
 
         Returns:
             A Prompt object containing details of the created or retrieved prompt.
 
         Raises:
-            ApiError: If there is an error during the creation of the prompt and the status code is not 409.
+            PromptTemplateStructureMismatch: If a chat prompt with the same name already exists (template structure is immutable).
+            ApiError: If there is an error during the creation of the prompt.
         """
-        prompt_client = PromptClient(self._rest_client)
-        return prompt_client.create_prompt(name=name, prompt=prompt, metadata=metadata)
+        prompt_client_ = prompt_client.PromptClient(self._rest_client)
+        prompt_version = prompt_client_.create_prompt(
+            name=name, prompt=prompt, metadata=metadata, type=type
+        )
+        return prompt_module.Prompt.from_fern_prompt_version(name, prompt_version)
+
+    def create_chat_prompt(
+        self,
+        name: str,
+        messages: List[Dict[str, Any]],
+        metadata: Optional[Dict[str, Any]] = None,
+        type: prompt_module.PromptType = prompt_module.PromptType.MUSTACHE,
+    ) -> prompt_module.ChatPrompt:
+        """
+        Creates a new chat prompt with the given name and message templates.
+        If a chat prompt with the same name already exists, it will create a new version if the messages differ.
+
+        Parameters:
+            name: The name of the chat prompt.
+            messages: List of message dictionaries with 'role' and 'content' fields.
+            metadata: Optional metadata to be included in the prompt.
+            type: The template type (MUSTACHE or JINJA2).
+
+        Returns:
+            A ChatPrompt object containing details of the created or retrieved chat prompt.
+
+        Raises:
+            PromptTemplateStructureMismatch: If a text prompt with the same name already exists (template structure is immutable).
+            ApiError: If there is an error during the creation of the prompt.
+        """
+        return prompt_module.ChatPrompt(
+            name=name, messages=messages, metadata=metadata, type=type
+        )
 
     def get_prompt(
         self,
         name: str,
         commit: Optional[str] = None,
-    ) -> Optional[Prompt]:
+    ) -> Optional[prompt_module.Prompt]:
         """
-        Retrieve the prompt detail for a given prompt name and commit version.
+        Retrieve a text prompt by name and optional commit version.
+
+        This method only returns text prompts.
 
         Parameters:
             name: The name of the prompt.
             commit: An optional commit version of the prompt. If not provided, the latest version is retrieved.
 
         Returns:
-            Prompt: The details of the specified prompt.
+            Prompt: The details of the specified text prompt, or None if not found.
+
+        Raises:
+            PromptTemplateStructureMismatch: If the prompt exists but is a chat prompt (template structure mismatch).
         """
-        prompt_client = PromptClient(self._rest_client)
-        return prompt_client.get_prompt(name=name, commit=commit)
+        prompt_client_ = prompt_client.PromptClient(self._rest_client)
+        fern_prompt_version = prompt_client_.get_prompt(
+            name=name, commit=commit, raise_if_not_template_structure="text"
+        )
 
-    def get_all_prompts(self, name: str) -> List[Prompt]:
+        if fern_prompt_version is None:
+            return None
+
+        return prompt_module.Prompt.from_fern_prompt_version(name, fern_prompt_version)
+
+    def get_chat_prompt(
+        self,
+        name: str,
+        commit: Optional[str] = None,
+    ) -> Optional[prompt_module.ChatPrompt]:
         """
-        Retrieve all the prompt versions for a given prompt name.
+        Retrieve a chat prompt by name and optional commit version.
+
+        This method only returns chat prompts.
 
         Parameters:
             name: The name of the prompt.
+            commit: An optional commit version of the prompt. If not provided, the latest version is retrieved.
+
+        Returns:
+            ChatPrompt: The details of the specified chat prompt, or None if not found.
+
+        Raises:
+            PromptTemplateStructureMismatch: If the prompt exists but is a text prompt (template structure mismatch).
+        """
+        prompt_client_ = prompt_client.PromptClient(self._rest_client)
+        fern_prompt_version = prompt_client_.get_prompt(
+            name=name, commit=commit, raise_if_not_template_structure="chat"
+        )
+
+        if fern_prompt_version is None:
+            return None
+
+        return prompt_module.ChatPrompt.from_fern_prompt_version(
+            name, fern_prompt_version
+        )
+
+    def get_prompt_history(self, name: str) -> List[prompt_module.Prompt]:
+        """
+        Retrieve all text prompt versions history for a given prompt name.
+
+        Parameters:
+            name: The name of the prompt.
+
+        Returns:
+            List[Prompt]: A list of text Prompt instances for the given name, or an empty list if not found.
+
+        Raises:
+            PromptTemplateStructureMismatch: If the prompt exists but is a chat prompt (template structure mismatch).
+        """
+        prompt_client_ = prompt_client.PromptClient(self._rest_client)
+
+        # First, validate that this is a text prompt by trying to get the latest version
+        # Let PromptTemplateStructureMismatch exception propagate - this is a hard error
+        latest_version = prompt_client_.get_prompt(
+            name=name, raise_if_not_template_structure="text"
+        )
+
+        if latest_version is None:
+            return []
+
+        # Now get all versions (we know it's a text prompt)
+        fern_prompt_versions = prompt_client_.get_all_prompt_versions(name=name)
+
+        result = [
+            prompt_module.Prompt.from_fern_prompt_version(name, version)
+            for version in fern_prompt_versions
+        ]
+        return result
+
+    def get_chat_prompt_history(self, name: str) -> List[prompt_module.ChatPrompt]:
+        """
+        Retrieve all chat prompt versions history for a given prompt name.
+
+        Parameters:
+            name: The name of the prompt.
+
+        Returns:
+            List[ChatPrompt]: A list of ChatPrompt instances for the given name, or an empty list if not found.
+
+        Raises:
+            PromptTemplateStructureMismatch: If the prompt exists but is a text prompt (template structure mismatch).
+        """
+        prompt_client_ = prompt_client.PromptClient(self._rest_client)
+
+        # First, validate that this is a chat prompt by trying to get the latest version
+        # Let PromptTemplateStructureMismatch exception propagate - this is a hard error
+        latest_version = prompt_client_.get_prompt(
+            name=name, raise_if_not_template_structure="chat"
+        )
+
+        if latest_version is None:
+            return []
+
+        # Now get all versions (we know it's a chat prompt)
+        fern_prompt_versions = prompt_client_.get_all_prompt_versions(name=name)
+
+        result = [
+            prompt_module.ChatPrompt.from_fern_prompt_version(name, version)
+            for version in fern_prompt_versions
+        ]
+        return result
+
+    def get_all_prompts(self, name: str) -> List[prompt_module.Prompt]:
+        """
+        DEPRECATED: Please use Opik.get_prompt_history() instead.
+        Retrieve all the prompt versions history for a given prompt name.
+
+        Parameters:
+            name: The name of the prompt.
+
+        Returns:
+            List[prompt_module.Prompt]: A list of Prompt instances for the given name.
+        """
+        LOGGER.warning(
+            "Opik.get_all_prompts() is deprecated. Please use Opik.get_prompt_history() instead."
+        )
+        return self.get_prompt_history(name)
+
+    def search_prompts(
+        self, filter_string: Optional[str] = None
+    ) -> List[Union[prompt_module.Prompt, prompt_module.ChatPrompt]]:
+        """
+        Retrieve the latest prompt versions (both string and chat prompts) for the given search parameters.
+
+        Parameters:
+            filter_string: A filter string to narrow down the search using Opik Query Language (OQL).
+                The format is: "<COLUMN> <OPERATOR> <VALUE> [AND <COLUMN> <OPERATOR> <VALUE>]*"
+
+                Supported columns include:
+                - `id`, `name`: String fields
+                - `tags`: List field (use "contains" operator only)
+                - `created_by`: String field
+                - `template_structure`: String field ("string" or "chat")
+
+                Supported operators by column:
+                - `id`: =, !=, contains, not_contains, starts_with, ends_with, >, <
+                - `name`: =, !=, contains, not_contains, starts_with, ends_with, >, <
+                - `created_by`: =, !=, contains, not_contains, starts_with, ends_with, >, <
+                - `template_structure`: =, !=
+                - `tags`: contains (only)
+
+                Examples:
+                - `tags contains "alpha"` - Filter by tag
+                - `tags contains "alpha" AND tags contains "beta"` - Filter by multiple tags
+                - `name contains "summary"` - Filter by name substring
+                - `created_by = "user@example.com"` - Filter by creator
+                - `id starts_with "prompt_"` - Filter by ID prefix
+                - `template_structure = "text"` - Only text prompts
+                - `template_structure = "chat"` - Only chat prompts
+
+                If not provided, all prompts (both text and chat) will be returned.
+
+        Returns:
+            List[Union[Prompt, ChatPrompt]]: A list of Prompt and/or ChatPrompt instances found.
+        """
+        oql = opik_query_language.OpikQueryLanguage(filter_string or "")
+        parsed_filters = oql.get_filter_expressions()
+
+        prompt_client_ = prompt_client.PromptClient(self._rest_client)
+        search_results = prompt_client_.search_prompts(parsed_filters=parsed_filters)
+
+        # Convert to Prompt or ChatPrompt objects based on template_structure
+        prompts: List[Union[prompt_module.Prompt, prompt_module.ChatPrompt]] = []
+        for result in search_results:
+            if result.template_structure == "chat":
+                prompts.append(
+                    prompt_module.ChatPrompt.from_fern_prompt_version(
+                        result.name, result.prompt_version_detail
+                    )
+                )
+            else:
+                prompts.append(
+                    prompt_module.Prompt.from_fern_prompt_version(
+                        result.name, result.prompt_version_detail
+                    )
+                )
+
+        return prompts
+
+    def create_optimization(
+        self,
+        dataset_name: str,
+        objective_name: str,
+        name: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        optimization_id: Optional[str] = None,
+    ) -> optimization.Optimization:
+        id = optimization_id or id_helpers.generate_id()
+
+        self._rest_client.optimizations.create_optimization(
+            id=id,
+            name=name,
+            dataset_name=dataset_name,
+            objective_name=objective_name,
+            status="running",
+            metadata=metadata,
+        )
+
+        optimization_client = optimization.Optimization(
+            id=id, rest_client=self._rest_client
+        )
+        return optimization_client
+
+    def delete_optimizations(self, ids: List[str]) -> None:
+        self._rest_client.optimizations.delete_optimizations_by_id(ids=ids)
+
+    def get_optimization_by_id(self, id: str) -> optimization.Optimization:
+        _ = self._rest_client.optimizations.get_optimization_by_id(id)
+        return optimization.Optimization(id=id, rest_client=self._rest_client)
+
+    def get_experiments_client(self) -> experiments_client.ExperimentsClient:
+        """
+        Retrieves an instance of `ExperimentsClient`.
 
         Returns:
-            List[Prompt]: A list of prompts for the given name.
+            An instance of the ExperimentsClient initialized with a cached REST client.
         """
-        prompt_client = PromptClient(self._rest_client)
-        return prompt_client.get_all_prompts(name=name)
+        return experiments_client.ExperimentsClient(self._rest_client)
 
 
 @functools.lru_cache()