MindsDB 25.1.2.1__py3-none-any.whl → 25.1.3.0__py3-none-any.whl

mindsdb/integrations/handlers/postgres_handler/postgres_handler.py

@@ -161,7 +161,7 @@ class PostgresHandler(DatabaseHandler):
             'float8': 'float64'
         }
         columns = df.columns
-        df = df.set_axis(range(len(columns)), axis=1)
+        df.columns = list(range(len(columns)))
         for column_index, column_name in enumerate(df.columns):
             col = df[column_name]
             if str(col.dtype) == 'object':
@@ -172,7 +172,7 @@ class PostgresHandler(DatabaseHandler):
                         df[column_name] = col.astype(types_map[pg_type.name])
                     except ValueError as e:
                         logger.error(f'Error casting column {col.name} to {types_map[pg_type.name]}: {e}')
-        return df.set_axis(columns, axis=1)
+        df.columns = columns
 
     @profiler.profile()
     def native_query(self, query: str, params=None) -> Response:
@@ -202,7 +202,7 @@ class PostgresHandler(DatabaseHandler):
                         result,
                         columns=[x.name for x in cur.description]
                     )
-                    df = self._cast_dtypes(df, cur.description)
+                    self._cast_dtypes(df, cur.description)
                     response = Response(
                         RESPONSE_TYPE.TABLE,
                         df

mindsdb/integrations/utilities/rag/loaders/vector_store_loader/pgvector.py

@@ -1,9 +1,9 @@
-from typing import Any, List, Optional, Dict
+from typing import Any, List, Union, Optional, Dict
 
 from langchain_community.vectorstores import PGVector
 from langchain_community.vectorstores.pgvector import Base
 
-from pgvector.sqlalchemy import Vector
+from pgvector.sqlalchemy import SPARSEVEC, Vector
 import sqlalchemy as sa
 from sqlalchemy.dialects.postgresql import JSON
 
@@ -15,9 +15,17 @@ _generated_sa_tables = {}
 
 class PGVectorMDB(PGVector):
     """
-       langchain_community.vectorstores.PGVector adapted for mindsdb vector store table structure
+    langchain_community.vectorstores.PGVector adapted for mindsdb vector store table structure
     """
 
+    def __init__(self, *args, is_sparse: bool = False, vector_size: Optional[int] = None, **kwargs):
+        # todo get is_sparse and vector_size from kb vector table
+        self.is_sparse = is_sparse
+        if is_sparse and vector_size is None:
+            raise ValueError("vector_size is required when is_sparse=True")
+        self.vector_size = vector_size
+        super().__init__(*args, **kwargs)
+
     def __post_init__(
         self,
     ) -> None:
@@ -32,53 +40,94 @@ class PGVectorMDB(PGVector):
                 __tablename__ = collection_name
 
                 id = sa.Column(sa.Integer, primary_key=True)
-                embedding: Vector = sa.Column('embeddings', Vector())
-                document = sa.Column('content', sa.String, nullable=True)
-                cmetadata = sa.Column('metadata', JSON, nullable=True)
+                embedding = sa.Column(
+                    "embeddings",
+                    SPARSEVEC() if self.is_sparse else Vector() if self.vector_size is None else
+                    SPARSEVEC(self.vector_size) if self.is_sparse else Vector(self.vector_size)
+                )
+                document = sa.Column("content", sa.String, nullable=True)
+                cmetadata = sa.Column("metadata", JSON, nullable=True)
 
             _generated_sa_tables[collection_name] = EmbeddingStore
 
         self.EmbeddingStore = _generated_sa_tables[collection_name]
 
     def __query_collection(
-        self,
-        embedding: List[float],
-        k: int = 4,
-        filter: Optional[Dict[str, str]] = None,
+            self,
+            embedding: Union[List[float], Dict[int, float], str],
+            k: int = 4,
+            filter: Optional[Dict[str, str]] = None,
     ) -> List[Any]:
         """Query the collection."""
         with Session(self._bind) as session:
-
-            results: List[Any] = (
-                session.query(
-                    self.EmbeddingStore,
-                    self.distance_strategy(embedding).label("distance"),
-                )
-                .order_by(sa.asc("distance"))
-                .limit(k)
-                .all()
+            if self.is_sparse:
+                # Sparse vectors: expect string in format "{key:value,...}/size" or dictionary
+                if isinstance(embedding, dict):
+                    from pgvector.utils import SparseVector
+                    embedding = SparseVector(embedding, self.vector_size)
+                    embedding_str = embedding.to_text()
+                elif isinstance(embedding, str):
+                    # Use string as is - it should already be in the correct format
+                    embedding_str = embedding
+                # Use inner product for sparse vectors
+                distance_op = "<#>"
+                # For inner product, larger values are better matches
+                order_direction = "DESC"
+            else:
+                # Dense vectors: expect string in JSON array format or list of floats
+                if isinstance(embedding, list):
+                    embedding_str = f"[{','.join(str(x) for x in embedding)}]"
+                elif isinstance(embedding, str):
+                    embedding_str = embedding
+                # Use cosine similarity for dense vectors
+                distance_op = "<=>"
+                # For cosine similarity, smaller values are better matches
+                order_direction = "ASC"
+
+            # Use SQL directly for vector comparison
+            query = sa.text(
+                f"""
+            SELECT t.*, t.embeddings {distance_op} '{embedding_str}' as distance
+            FROM {self.collection_name} t
+            ORDER BY distance {order_direction}
+            LIMIT {k}
+            """
             )
-        for rec, _ in results:
-            if not bool(rec.cmetadata):
-                rec.cmetadata = {0: 0}
+            results = session.execute(query).all()
+
+            # Convert results to the expected format
+            formatted_results = []
+            for rec in results:
+                metadata = rec.metadata if bool(rec.metadata) else {0: 0}
+                embedding_store = self.EmbeddingStore()
+                embedding_store.document = rec.content
+                embedding_store.cmetadata = metadata
+                result = type(
+                    'Result', (), {
+                        'EmbeddingStore': embedding_store,
+                        'distance': rec.distance
+                    }
+                )
+                formatted_results.append(result)
 
-        return results
+            return formatted_results
 
     # aliases for different langchain versions
     def _PGVector__query_collection(self, *args, **kwargs):
+
         return self.__query_collection(*args, **kwargs)
 
     def _query_collection(self, *args, **kwargs):
         return self.__query_collection(*args, **kwargs)
 
     def create_collection(self):
-        raise RuntimeError('Forbidden')
+        raise RuntimeError("Forbidden")
 
     def delete_collection(self):
-        raise RuntimeError('Forbidden')
+        raise RuntimeError("Forbidden")
 
     def delete(self, *args, **kwargs):
-        raise RuntimeError('Forbidden')
+        raise RuntimeError("Forbidden")
 
     def add_embeddings(self, *args, **kwargs):
-        raise RuntimeError('Forbidden')
+        raise RuntimeError("Forbidden")

mindsdb/integrations/utilities/rag/loaders/vector_store_loader/vector_store_loader.py

@@ -7,6 +7,7 @@ from pydantic import BaseModel
 
 from mindsdb.integrations.utilities.rag.settings import VectorStoreType, VectorStoreConfig
 from mindsdb.integrations.utilities.rag.loaders.vector_store_loader.MDBVectorStore import MDBVectorStore
+from mindsdb.integrations.utilities.rag.loaders.vector_store_loader.pgvector import PGVectorMDB
 from mindsdb.utilities import log
 
 
@@ -28,6 +29,20 @@ class VectorStoreLoader(BaseModel):
         Loads the vector store based on the provided config and embeddings model
         :return:
         """
+        if self.config.is_sparse is not None and self.config.vector_size is not None and self.config.kb_table is not None:
+            # Only use PGVector store for sparse vectors.
+            db_handler = self.config.kb_table.get_vector_db()
+            db_args = db_handler.connection_args
+            # Assume we are always using PGVector & psycopg2.
+            connection_str = f"postgresql+psycopg2://{db_args.get('user')}:{db_args.get('password')}@{db_args.get('host')}:{db_args.get('port')}/{db_args.get('dbname', db_args.get('database'))}"
+
+            return PGVectorMDB(
+                connection_string=connection_str,
+                collection_name=self.config.kb_table._kb.vector_database_table,
+                embedding_function=self.embedding_model,
+                is_sparse=self.config.is_sparse,
+                vector_size=self.config.vector_size
+            )
         return MDBVectorStore(kb_table=self.config.kb_table)
 
 
@@ -56,5 +71,7 @@ class VectorStoreFactory:
         return PGVectorMDB(
             connection_string=settings.connection_string,
             collection_name=settings.collection_name,
-            embedding_function=embedding_model
+            embedding_function=embedding_model,
+            is_sparse=settings.is_sparse,
+            vector_size=settings.vector_size
         )

mindsdb/integrations/utilities/rag/retrievers/sql_retriever.py

@@ -169,7 +169,7 @@ Output:
             logger.info(f'SQL Retriever query {checked_sql_query} failed with error {error_msg}')
             if num_retries >= self.num_retries:
                 logger.info('Using fallback retriever in SQL retriever.')
-                return self.fallback_retriever._get_relevant_documents(retrieval_query, run_manager)
+                return self.fallback_retriever._get_relevant_documents(retrieval_query, run_manager=run_manager)
             query_to_retry = self._prepare_retry_query(checked_sql_query, error_msg, run_manager)
             query_to_retry_with_embeddings = query_to_retry.format(embeddings=str(embedded_query))
             # Handle LLM output that has the ```sql delimiter possibly.
@@ -185,4 +185,8 @@ Output:
                 document_row.get('content', ''),
                 metadata=document_row.get('metadata', {})
             ))
-        return retrieved_documents
+        if retrieved_documents:
+            return retrieved_documents
+        # If the SQL query constructed did not return any documents, fallback.
+        logger.info('No documents returned from SQL retriever. using fallback retriever.')
+        return self.fallback_retriever._get_relevant_documents(retrieval_query, run_manager=run_manager)

mindsdb/integrations/utilities/rag/settings.py

@@ -290,6 +290,8 @@ class VectorStoreConfig(BaseModel):
     collection_name: str = DEFAULT_COLLECTION_NAME
     connection_string: str = None
     kb_table: Any = None
+    is_sparse: bool = False
+    vector_size: Optional[int] = None
 
     class Config:
         arbitrary_types_allowed = True

mindsdb/integrations/utilities/sql_utils.py

@@ -178,7 +178,7 @@ def project_dataframe(df, targets, table_columns):
 
     # adapt column names to projection
     if len(df_col_rename) > 0:
-        df = df.rename(columns=df_col_rename)
+        df.rename(columns=df_col_rename, inplace=True)
     return df
 
 

mindsdb/interfaces/knowledge_base/controller.py

@@ -642,11 +642,13 @@ class KnowledgeBaseController:
             storage: Identifier,
             params: dict,
             preprocessing_config: Optional[dict] = None,
-            if_not_exists: bool = False,
+            if_not_exists: bool = False
     ) -> db.KnowledgeBase:
         """
         Add a new knowledge base to the database
         :param preprocessing_config: Optional preprocessing configuration to validate and store
+        :param is_sparse: Whether to use sparse vectors for embeddings
+        :param vector_size: Optional size specification for vectors, required when is_sparse=True
         """
         # Validate preprocessing config first if provided
         if preprocessing_config is not None:
@@ -654,6 +656,12 @@ class KnowledgeBaseController:
             params = params or {}
             params['preprocessing'] = preprocessing_config
 
+        # Check if vector_size is provided when using sparse vectors
+        is_sparse = params.get('is_sparse')
+        vector_size = params.get('vector_size')
+        if is_sparse and vector_size is None:
+            raise ValueError("vector_size is required when is_sparse=True")
+
         # get project id
         project = self.session.database_controller.get_project(project_name)
         project_id = project.id
@@ -693,7 +701,20 @@ class KnowledgeBaseController:
             cloud_pg_vector = os.environ.get('KB_PGVECTOR_URL')
             if cloud_pg_vector:
                 vector_table_name = name
-                vector_db_name = self._create_persistent_pgvector()
+                # Add sparse vector support for pgvector
+                vector_db_params = {}
+                # Check both explicit parameter and model configuration
+                is_sparse = is_sparse or model_record.learn_args.get('using', {}).get('sparse')
+                if is_sparse:
+                    vector_db_params['is_sparse'] = True
+                    if vector_size is not None:
+                        vector_db_params['vector_size'] = vector_size
+                vector_db_name = self._create_persistent_pgvector(vector_db_params)
+
+                # create table in vectordb before creating KB
+                self.session.datahub.get(vector_db_name).integration_handler.create_table(
+                    vector_table_name
+                )
             else:
                 # create chroma db with same name
                 vector_table_name = "default_collection"
@@ -707,15 +728,14 @@ class KnowledgeBaseController:
 
         vector_database_id = self.session.integration_controller.get(vector_db_name)['id']
 
-        # create table in vectordb
-        if model_record.learn_args.get('using', {}).get('sparse') is not None:
-            self.session.datahub.get(vector_db_name).integration_handler.create_table(
-                vector_table_name, sparse=model_record.learn_args.get('using', {}).get('sparse')
-            )
-        else:
-            self.session.datahub.get(vector_db_name).integration_handler.create_table(
-                vector_table_name
-            )
+        # Store sparse vector settings in params if specified
+        if is_sparse:
+            params = params or {}
+            params['vector_config'] = {
+                'is_sparse': is_sparse
+            }
+            if vector_size is not None:
+                params['vector_config']['vector_size'] = vector_size
 
         kb = db.KnowledgeBase(
             name=name,
@@ -729,16 +749,15 @@ class KnowledgeBaseController:
         db.session.commit()
         return kb
 
-    def _create_persistent_pgvector(self):
+    def _create_persistent_pgvector(self, params=None):
         """Create default vector database for knowledge base, if not specified"""
-
         vector_store_name = "kb_pgvector_store"
 
         # check if exists
         if self.session.integration_controller.get(vector_store_name):
             return vector_store_name
 
-        self.session.integration_controller.add(vector_store_name, 'pgvector', {})
+        self.session.integration_controller.add(vector_store_name, 'pgvector', params or {})
         return vector_store_name
 
     def _create_persistent_chroma(self, kb_name, engine="chromadb"):

mindsdb/interfaces/skills/retrieval_tool.py

@@ -43,10 +43,17 @@ def build_retrieval_tool(tool: dict, pred_args: dict, skill: db.Skills):
             raise ValueError(f"Knowledge base not found: {kb_name}")
 
         kb_table = executor.session.kb_controller.get_table(kb.name, kb.project_id)
+        vector_store_config = {
+            'kb_table': kb_table
+        }
+        is_sparse = tools_config.pop('is_sparse', None)
+        vector_size = tools_config.pop('vector_size', None)
+        if is_sparse is not None:
+            vector_store_config['is_sparse'] = is_sparse
+        if vector_size is not None:
+            vector_store_config['vector_size'] = vector_size
         kb_params = {
-            'vector_store_config': {
-                'kb_table': kb_table
-            }
+            'vector_store_config': vector_store_config
         }
 
         # Get embedding model from knowledge base table

mindsdb/utilities/cache.py

@@ -71,10 +71,13 @@ _CACHE_MAX_SIZE = 500
 
 
 def dataframe_checksum(df: pd.DataFrame):
-
-    return str_checksum(str(
-        df.set_axis(range(len(df.columns)), axis=1).to_records(index=False)
-    ))
+    original_columns = df.columns
+    df.columns = list(range(len(df.columns)))
+    result = hashlib.sha256(
+        str(df.values).encode()
+    ).hexdigest()
+    df.columns = original_columns
+    return result
 
 
 def json_checksum(obj: t.Union[dict, list]):

mindsdb/utilities/context.py

@@ -52,6 +52,15 @@ class Context:
     def load(self, storage: dict) -> None:
         self._storage.set(storage)
 
+    def metadata(self, **kwargs) -> dict:
+        return {
+            'user_id': self.user_id or "",
+            'company_id': self.company_id or "",
+            'session_id': self.session_id,
+            'user_class': self.user_class,
+            **kwargs
+        }
+
 
 _context_var = ContextVar('mindsdb.context')
 context = Context(_context_var)

mindsdb/utilities/log.py

@@ -29,6 +29,23 @@ class ColorFormatter(logging.Formatter):
         return log_fmt.format(record)
 
 
+def get_console_handler_config_level() -> int:
+    console_handler_config = app_config['logging']['handlers']['console']
+    return getattr(logging, console_handler_config["level"])
+
+
+def get_file_handler_config_level() -> int:
+    file_handler_config = app_config['logging']['handlers']['file']
+    return getattr(logging, file_handler_config["level"])
+
+
+def get_mindsdb_log_level() -> int:
+    console_handler_config_level = get_console_handler_config_level()
+    file_handler_config_level = get_file_handler_config_level()
+
+    return min(console_handler_config_level, file_handler_config_level)
+
+
 def configure_logging():
     handlers_config = {}
     console_handler_config = app_config['logging']['handlers']['console']
@@ -39,6 +56,7 @@ def configure_logging():
             "formatter": "f",
             "level": console_handler_config_level
         }
+
     file_handler_config = app_config['logging']['handlers']['file']
     file_handler_config_level = getattr(logging, file_handler_config["level"])
     if file_handler_config['enabled'] is True:
@@ -51,7 +69,7 @@ def configure_logging():
             "backupCount": file_handler_config["backupCount"]
         }
 
-    mindsdb_log_level = min(console_handler_config_level, file_handler_config_level)
+    mindsdb_log_level = get_mindsdb_log_level()
 
     logging_config = dict(
         version=1,
@@ -65,7 +83,7 @@ def configure_logging():
         loggers={
             "": {  # root logger
                 "handlers": list(handlers_config.keys()),
-                "level": logging.WARNING,
+                "level": mindsdb_log_level,
             },
             "__main__": {
                 "level": mindsdb_log_level,

mindsdb/utilities/otel/__init__.py

@@ -0,0 +1,206 @@
+import os
+import typing
+
+from opentelemetry import trace  # noqa: F401
+from opentelemetry import metrics  # noqa: F401
+from opentelemetry.exporter.otlp.proto.grpc._log_exporter import OTLPLogExporter as OTLPLogExporterGRPC
+from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter as OTLPLogExporterHTTP
+from opentelemetry.sdk._logs._internal.export import LogExporter
+from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import OTLPMetricExporter as OTLPMetricExporterGRPC
+from opentelemetry.exporter.otlp.proto.http.metric_exporter import OTLPMetricExporter as OTLPMetricExporterHTTP
+from opentelemetry.sdk.metrics.export import MetricExporter, ConsoleMetricExporter
+from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter as OTLPSpanExporterGRPC
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter as OTLPSpanExporterHTTP
+from opentelemetry.sdk.trace.export import SpanExporter, ConsoleSpanExporter
+from opentelemetry.sdk.resources import Resource
+from opentelemetry.sdk.trace.sampling import TraceIdRatioBased
+
+from mindsdb.utilities.otel.logger import setup_logger
+from mindsdb.utilities.otel.meter import setup_meter
+from mindsdb.utilities.otel.tracer import setup_tracer
+from mindsdb.utilities.utils import parse_csv_attributes
+from mindsdb.utilities import log
+
+logger = log.getLogger(__name__)
+
+# Check OpenTelemetry exporter type
+OTEL_EXPORTER_TYPE = os.getenv("OTEL_EXPORTER_TYPE", "console")  # console or otlp
+
+# Define OpenTelemetry exporter protocol
+OTEL_EXPORTER_PROTOCOL = os.getenv("OTEL_EXPORTER_PROTOCOL", "grpc")  # grpc or http
+
+# Define OTLP endpoint. If not set, the default OTLP endpoint will be used
+OTEL_OTLP_ENDPOINT = os.getenv("OTEL_OTLP_ENDPOINT", "http://localhost:4317")
+
+# Define OTLP logging endpoint. If not set, the default OTLP logging endpoint will be used
+OTEL_OTLP_LOGGING_ENDPOINT = os.getenv("OTEL_OTLP_LOGGING_ENDPOINT", OTEL_OTLP_ENDPOINT)
+
+# Define OTLP tracing endpoint. If not set, the default OTLP tracing endpoint will be used
+OTEL_OTLP_TRACING_ENDPOINT = os.getenv("OTEL_OTLP_TRACING_ENDPOINT", OTEL_OTLP_ENDPOINT)
+
+# Define OTLP metrics endpoint. If not set, the default OTLP metrics endpoint will be used
+OTEL_OTLP_METRICS_ENDPOINT = os.getenv("OTEL_OTLP_METRICS_ENDPOINT", OTEL_OTLP_ENDPOINT)
+
+# Define service name
+OTEL_SERVICE_NAME = os.getenv("OTEL_SERVICE_NAME", "mindsdb")
+
+# Define service instace ID
+OTEL_SERVICE_INSTANCE_ID = os.getenv("OTEL_SERVICE_INSTANCE_ID", "mindsdb-instance")
+
+# The name of the environment we"re on, by default local for development, this is set differently per-env in our Helm
+# chart values files
+OTEL_SERVICE_ENVIRONMENT = os.getenv("OTEL_SERVICE_ENVIRONMENT", "local").lower()
+
+# Define service release
+OTEL_SERVICE_RELEASE = os.getenv("OTEL_SERVICE_RELEASE", "local").lower()
+
+# Define how often to capture traces
+OTEL_TRACE_SAMPLE_RATE = float(os.getenv("OTEL_TRACE_SAMPLE_RATE", "1.0"))
+
+# Define extra attributes
+OTEL_EXTRA_ATTRIBUTES = os.getenv("OTEL_EXTRA_ATTRIBUTES", "")
+
+# By default, we have Open Telemetry SDK enabled on all envs, except for local which is disabled by default.
+OTEL_SDK_DISABLED = (os.getenv("OTEL_SDK_DISABLED", "false").lower() == "true"
+                     or os.getenv("OTEL_SERVICE_ENVIRONMENT", "local").lower() == "local")
+
+# Define if OpenTelemetry logging is disabled. By default, it is disabled.
+OTEL_LOGGING_DISABLED = os.getenv("OTEL_LOGGING_DISABLED", "true").lower() == "true"
+
+# Define if OpenTelemetry tracing is disabled. By default, it is enabled.
+OTEL_TRACING_DISABLED = os.getenv("OTEL_TRACING_DISABLED", "false").lower() == "true"
+
+# Define if OpenTelemetry metrics is disabled. By default, it is disabled.
+OTEL_METRICS_DISABLED = os.getenv("OTEL_METRICS_DISABLED", "true").lower() == "true"
+
+# If you want to enable Open Telemetry on local for some reason please set OTEL_SDK_FORCE_RUN to true
+OTEL_SDK_FORCE_RUN = os.getenv("OTEL_SDK_FORCE_RUN", "false").lower() == "true"
+
+
+def get_otel_attributes() -> dict:
+    """
+    Get OpenTelemetry attributes
+
+    Returns:
+        dict: OpenTelemetry attributes
+    """
+
+    base_attributes = {
+        "service.name": OTEL_SERVICE_NAME,
+        "service.instance.id": OTEL_SERVICE_INSTANCE_ID,
+        "environment": OTEL_SERVICE_ENVIRONMENT,
+        "release": OTEL_SERVICE_RELEASE,
+    }
+
+    extra_attributes = {}
+    try:
+        extra_attributes = parse_csv_attributes(OTEL_EXTRA_ATTRIBUTES)
+    except Exception as e:
+        logger.error(f"Failed to parse OTEL_EXTRA_ATTRIBUTES: {e}")
+
+    attributes = {**extra_attributes, **base_attributes}  # Base attributes take precedence over extra attributes
+
+    return attributes
+
+
+def get_logging_exporter() -> typing.Optional[LogExporter]:
+    """
+    Get OpenTelemetry logging exporter.
+
+    Returns:
+        OTLPLogExporter: OpenTelemetry logging exporter
+    """
+
+    if OTEL_EXPORTER_TYPE == "otlp":
+
+        if OTEL_EXPORTER_PROTOCOL == "grpc":
+            return OTLPLogExporterGRPC(
+                endpoint=OTEL_OTLP_LOGGING_ENDPOINT,
+                insecure=True
+            )
+
+        elif OTEL_EXPORTER_PROTOCOL == "http":
+            return OTLPLogExporterHTTP(
+                endpoint=OTEL_OTLP_LOGGING_ENDPOINT
+            )
+
+    return None
+
+
+def get_span_exporter() -> SpanExporter:
+    """
+    Get OpenTelemetry span exporter
+
+    Returns:
+        OTLPSpanExporter: OpenTelemetry span exporter
+    """
+
+    if OTEL_EXPORTER_TYPE == "otlp":
+
+        if OTEL_EXPORTER_PROTOCOL == "grpc":
+            return OTLPSpanExporterGRPC(
+                endpoint=OTEL_OTLP_TRACING_ENDPOINT,
+                insecure=True
+            )
+
+        elif OTEL_EXPORTER_PROTOCOL == "http":
+            return OTLPSpanExporterHTTP(
+                endpoint=OTEL_OTLP_TRACING_ENDPOINT
+            )
+
+    return ConsoleSpanExporter()
+
+
+def get_metrics_exporter() -> typing.Optional[MetricExporter]:
+    """
+    Get OpenTelemetry metrics exporter
+
+    Returns:
+        OTLPLogExporter: OpenTelemetry metrics exporter
+    """
+
+    if OTEL_EXPORTER_TYPE == "otlp":
+
+        if OTEL_EXPORTER_PROTOCOL == "grpc":
+            return OTLPMetricExporterGRPC(
+                endpoint=OTEL_OTLP_METRICS_ENDPOINT,
+                insecure=True
+            )
+
+        elif OTEL_EXPORTER_PROTOCOL == "http":
+            return OTLPMetricExporterHTTP(
+                endpoint=OTEL_OTLP_METRICS_ENDPOINT
+            )
+
+    return ConsoleMetricExporter()
+
+
+if not OTEL_SDK_DISABLED or OTEL_SDK_FORCE_RUN:
+    logger.info("OpenTelemetry enabled")
+    logger.info(f"OpenTelemetry exporter type: {OTEL_EXPORTER_TYPE}")
+    logger.info(f"OpenTelemetry service name: {OTEL_SERVICE_NAME}")
+    logger.info(f"OpenTelemetry service environment: {OTEL_SERVICE_ENVIRONMENT}")
+    logger.info(f"OpenTelemetry service release: {OTEL_SERVICE_RELEASE}")
+    logger.info(f"OpenTelemetry trace sample rate: {OTEL_TRACE_SAMPLE_RATE}")
+    logger.info(f"OpenTelemetry extra attributes: {OTEL_EXTRA_ATTRIBUTES}")
+
+    # Define OpenTelemetry resources (e.g., service name)
+    attributes = get_otel_attributes()
+
+    # Define OpenTelemetry sampler
+    sampler = TraceIdRatioBased(OTEL_TRACE_SAMPLE_RATE)
+
+    # Define OpenTelemetry resources (e.g., service name)
+    resource = Resource(attributes=attributes)
+
+    if not OTEL_LOGGING_DISABLED:
+        logger.info("OpenTelemetry Logging is enabled")
+        setup_logger(resource, get_logging_exporter())
+
+    if not OTEL_TRACING_DISABLED:
+        logger.info("OpenTelemetry Tracing is enabled")
+        setup_tracer(resource, sampler, get_span_exporter())
+
+    if not OTEL_METRICS_DISABLED:
+        logger.info("OpenTelemetry Metrics is enabled")
+        setup_meter(resource, get_metrics_exporter())