Revert LangChain/OpenAI Agents changes, align Mem0 with slimmed spec

- Revert all changes to langchain and openai-agents-v2 packages
  (these should be separate PRs)
- Update Mem0 instrumentation to match slimmed-down memory spec:
  only 5 core attributes (store.id, record.id, record.content,
  query.text, search.result.count)
- Remove references to moved/removed attributes: memory.type,
  memory.scope, store.name, similarity.threshold, expiration_date

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: nagkumar91

instrumentation-genai/opentelemetry-instrumentation-langchain/CHANGELOG.md

@@ -13,6 +13,3 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   ([#3889](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/3889))
 - Added log and metrics provider to langchain genai utils handler
   ([#4214](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/4214))
-- Added retriever memory search span/event instrumentation aligned with the
-  GenAI memory semantic convention proposal.
-  ([#3250](https://github.com/open-telemetry/semantic-conventions/pull/3250))

instrumentation-genai/opentelemetry-instrumentation-langchain/src/opentelemetry/instrumentation/langchain/callback_handler.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Optional, Sequence
+from typing import Any, Optional, cast
 from uuid import UUID
 
 from langchain_core.callbacks import BaseCallbackHandler
@@ -24,60 +24,15 @@
 from opentelemetry.instrumentation.langchain.invocation_manager import (
     _InvocationManager,
 )
-from opentelemetry.semconv._incubating.attributes import (
-    gen_ai_attributes as GenAI,
-)
 from opentelemetry.util.genai.handler import TelemetryHandler
 from opentelemetry.util.genai.types import (
-    ContentCapturingMode,
     Error,
     InputMessage,
     LLMInvocation,
+    MessagePart,
     OutputMessage,
     Text,
 )
-from opentelemetry.util.genai.utils import (
-    get_content_capturing_mode,
-    is_experimental_mode,
-)
-
-GEN_AI_MEMORY_STORE_ID = getattr(
-    GenAI, "GEN_AI_MEMORY_STORE_ID", "gen_ai.memory.store.id"
-)
-GEN_AI_MEMORY_STORE_NAME = getattr(
-    GenAI, "GEN_AI_MEMORY_STORE_NAME", "gen_ai.memory.store.name"
-)
-GEN_AI_MEMORY_QUERY = getattr(
-    GenAI, "GEN_AI_MEMORY_QUERY", "gen_ai.memory.query"
-)
-GEN_AI_MEMORY_SEARCH_RESULT_COUNT = getattr(
-    GenAI,
-    "GEN_AI_MEMORY_SEARCH_RESULT_COUNT",
-    "gen_ai.memory.search.result.count",
-)
-GEN_AI_MEMORY_NAMESPACE = getattr(
-    GenAI, "GEN_AI_MEMORY_NAMESPACE", "gen_ai.memory.namespace"
-)
-
-_SEARCH_MEMORY_MEMBER = getattr(
-    getattr(GenAI, "GenAiOperationNameValues", object()),
-    "SEARCH_MEMORY",
-    None,
-)
-SEARCH_MEMORY_OPERATION = (
-    _SEARCH_MEMORY_MEMBER.value
-    if _SEARCH_MEMORY_MEMBER is not None
-    else "search_memory"
-)
-
-_RETRIEVAL_MEMBER = getattr(
-    getattr(GenAI, "GenAiOperationNameValues", object()),
-    "RETRIEVAL",
-    None,
-)
-RETRIEVAL_OPERATION = (
-    _RETRIEVAL_MEMBER.value if _RETRIEVAL_MEMBER is not None else "retrieval"
-)
 
 
 class OpenTelemetryLangChainCallbackHandler(BaseCallbackHandler):
@@ -90,62 +45,6 @@ def __init__(self, telemetry_handler: TelemetryHandler) -> None:
         self._telemetry_handler = telemetry_handler
         self._invocation_manager = _InvocationManager()
 
-    @staticmethod
-    def _resolve_retriever_store_name(
-        serialized: dict[str, Any],
-        metadata: Optional[dict[str, Any]],
-    ) -> Optional[str]:
-        if metadata and metadata.get("memory_store_name"):
-            return str(metadata["memory_store_name"])
-        if metadata and metadata.get("ls_retriever_name"):
-            return str(metadata["ls_retriever_name"])
-        name = serialized.get("name")
-        return str(name) if isinstance(name, str) and name else None
-
-    @staticmethod
-    def _resolve_retriever_store_id(
-        serialized: dict[str, Any],
-        metadata: Optional[dict[str, Any]],
-    ) -> Optional[str]:
-        if metadata and metadata.get("memory_store_id"):
-            return str(metadata["memory_store_id"])
-
-        serialized_id = serialized.get("id")
-        if isinstance(serialized_id, str) and serialized_id:
-            return serialized_id
-        if isinstance(serialized_id, list) and serialized_id:
-            try:
-                return ".".join(str(part) for part in serialized_id)
-            except TypeError:
-                return None
-        return None
-
-    @staticmethod
-    def _should_capture_memory_query() -> bool:
-        if not is_experimental_mode():
-            return False
-        try:
-            mode = get_content_capturing_mode()
-        except ValueError:
-            return False
-        return mode in (
-            ContentCapturingMode.SPAN_ONLY,
-            ContentCapturingMode.SPAN_AND_EVENT,
-        )
-
-    @staticmethod
-    def _is_memory_retriever(
-        metadata: Optional[dict[str, Any]],
-    ) -> bool:
-        """Detect if a retriever is a memory retriever based on metadata hints."""
-        if not metadata:
-            return False
-        return bool(
-            metadata.get("memory_store_name")
-            or metadata.get("memory_store_id")
-            or metadata.get("is_memory_retriever")
-        )
-
     def on_chat_model_start(
         self,
         serialized: dict[str, Any],
@@ -235,7 +134,11 @@ def on_chat_model_start(
                                     Text(content=text_value, type="text")
                                 )
 
-                input_messages.append(InputMessage(parts=parts, role=role))
+                input_messages.append(
+                    InputMessage(
+                        parts=cast(list[MessagePart], parts), role=role
+                    )
+                )
 
         llm_invocation = LLMInvocation(
             request_model=request_model,
@@ -308,7 +211,7 @@ def on_llm_end(
                     role = chat_generation.message.type
                     output_message = OutputMessage(
                         role=role,
-                        parts=parts,
+                        parts=cast(list[MessagePart], parts),
                         finish_reason=finish_reason,
                     )
                     output_messages.append(output_message)
@@ -370,100 +273,3 @@ def on_llm_error(
         )
         if llm_invocation.span and not llm_invocation.span.is_recording():
             self._invocation_manager.delete_invocation_state(run_id=run_id)
-
-    def on_retriever_start(
-        self,
-        serialized: dict[str, Any],
-        query: str,
-        *,
-        run_id: UUID,
-        parent_run_id: Optional[UUID] = None,
-        tags: Optional[list[str]] = None,
-        metadata: Optional[dict[str, Any]] = None,
-        **kwargs: Any,
-    ) -> None:
-        provider = "unknown"
-        if metadata is not None:
-            provider = metadata.get("ls_provider", "unknown")
-
-        attributes: dict[str, Any] = {}
-        is_memory = self._is_memory_retriever(metadata)
-        operation = (
-            SEARCH_MEMORY_OPERATION if is_memory else RETRIEVAL_OPERATION
-        )
-
-        if store_name := self._resolve_retriever_store_name(
-            serialized, metadata
-        ):
-            attributes[GEN_AI_MEMORY_STORE_NAME] = store_name
-        if store_id := self._resolve_retriever_store_id(serialized, metadata):
-            attributes[GEN_AI_MEMORY_STORE_ID] = store_id
-        if (
-            query
-            and self._should_capture_memory_query()
-            and isinstance(query, str)
-        ):
-            attributes[GEN_AI_MEMORY_QUERY] = query
-        if metadata and metadata.get("memory_namespace"):
-            attributes[GEN_AI_MEMORY_NAMESPACE] = metadata["memory_namespace"]
-
-        llm_invocation = LLMInvocation(
-            request_model="",
-            provider=provider,
-            operation_name=operation,
-            attributes=attributes,
-        )
-        llm_invocation = self._telemetry_handler.start_llm(
-            invocation=llm_invocation
-        )
-        if llm_invocation.span and store_name:
-            llm_invocation.span.update_name(f"{operation} {store_name}")
-        self._invocation_manager.add_invocation_state(
-            run_id=run_id,
-            parent_run_id=parent_run_id,
-            invocation=llm_invocation,
-        )
-
-    def on_retriever_end(
-        self,
-        documents: Sequence[Any],
-        *,
-        run_id: UUID,
-        parent_run_id: Optional[UUID] = None,
-        **kwargs: Any,
-    ) -> None:
-        llm_invocation = self._invocation_manager.get_invocation(run_id=run_id)
-        if llm_invocation is None or not isinstance(
-            llm_invocation, LLMInvocation
-        ):
-            return
-
-        llm_invocation.attributes[GEN_AI_MEMORY_SEARCH_RESULT_COUNT] = len(
-            documents
-        )
-        llm_invocation = self._telemetry_handler.stop_llm(
-            invocation=llm_invocation
-        )
-        if llm_invocation.span and not llm_invocation.span.is_recording():
-            self._invocation_manager.delete_invocation_state(run_id=run_id)
-
-    def on_retriever_error(
-        self,
-        error: BaseException,
-        *,
-        run_id: UUID,
-        parent_run_id: Optional[UUID] = None,
-        **kwargs: Any,
-    ) -> None:
-        llm_invocation = self._invocation_manager.get_invocation(run_id=run_id)
-        if llm_invocation is None or not isinstance(
-            llm_invocation, LLMInvocation
-        ):
-            return
-
-        error_otel = Error(message=str(error), type=type(error))
-        llm_invocation = self._telemetry_handler.fail_llm(
-            invocation=llm_invocation, error=error_otel
-        )
-        if llm_invocation.span and not llm_invocation.span.is_recording():
-            self._invocation_manager.delete_invocation_state(run_id=run_id)

instrumentation-genai/opentelemetry-instrumentation-mem0/src/opentelemetry/instrumentation/mem0/patch.py

@@ -54,23 +54,18 @@ def _attr(name: str, fallback: str) -> str:
 GEN_AI_MEMORY_STORE_ID = _attr(
     "GEN_AI_MEMORY_STORE_ID", "gen_ai.memory.store.id"
 )
-GEN_AI_MEMORY_STORE_NAME = _attr(
-    "GEN_AI_MEMORY_STORE_NAME", "gen_ai.memory.store.name"
+GEN_AI_MEMORY_RECORD_ID = _attr(
+    "GEN_AI_MEMORY_RECORD_ID", "gen_ai.memory.record.id"
 )
-GEN_AI_MEMORY_ID = _attr("GEN_AI_MEMORY_ID", "gen_ai.memory.id")
-GEN_AI_MEMORY_TYPE = _attr("GEN_AI_MEMORY_TYPE", "gen_ai.memory.type")
-GEN_AI_MEMORY_SCOPE = _attr("GEN_AI_MEMORY_SCOPE", "gen_ai.memory.scope")
-GEN_AI_MEMORY_QUERY = _attr("GEN_AI_MEMORY_QUERY", "gen_ai.memory.query")
-GEN_AI_MEMORY_CONTENT = _attr("GEN_AI_MEMORY_CONTENT", "gen_ai.memory.content")
-GEN_AI_MEMORY_NAMESPACE = _attr(
-    "GEN_AI_MEMORY_NAMESPACE", "gen_ai.memory.namespace"
+GEN_AI_MEMORY_RECORD_CONTENT = _attr(
+    "GEN_AI_MEMORY_RECORD_CONTENT", "gen_ai.memory.record.content"
+)
+GEN_AI_MEMORY_QUERY_TEXT = _attr(
+    "GEN_AI_MEMORY_QUERY_TEXT", "gen_ai.memory.query.text"
 )
 GEN_AI_MEMORY_SEARCH_RESULT_COUNT = _attr(
     "GEN_AI_MEMORY_SEARCH_RESULT_COUNT", "gen_ai.memory.search.result.count"
 )
-GEN_AI_MEMORY_UPDATE_STRATEGY = _attr(
-    "GEN_AI_MEMORY_UPDATE_STRATEGY", "gen_ai.memory.update.strategy"
-)
 ERROR_TYPE = getattr(ErrorAttributes, "ERROR_TYPE", "error.type")
 
 _PROVIDER = "mem0"
@@ -87,28 +82,6 @@ def _capture_content() -> bool:
     ).lower() in ("true", "1")
 
 
-def _scope_from_kwargs(kwargs: dict[str, Any]) -> Optional[str]:
-    """Infer memory scope from Mem0 filter kwargs."""
-    if kwargs.get("user_id"):
-        return "user"
-    if kwargs.get("agent_id"):
-        return "agent"
-    if kwargs.get("run_id"):
-        return "session"
-    return None
-
-
-def _namespace_from_kwargs(kwargs: dict[str, Any]) -> Optional[str]:
-    """Build namespace string from Mem0 identity kwargs."""
-    user_id = kwargs.get("user_id")
-    agent_id = kwargs.get("agent_id")
-    if user_id:
-        return f"user:{user_id}"
-    if agent_id:
-        return f"agent:{agent_id}"
-    return None
-
-
 def _set_common_attributes(
     span: trace.Span,
     operation: str,
@@ -119,14 +92,6 @@ def _set_common_attributes(
     span.set_attribute(GEN_AI_SYSTEM, _PROVIDER)
     span.set_attribute(GEN_AI_PROVIDER_NAME, _PROVIDER)
 
-    scope = _scope_from_kwargs(kwargs)
-    if scope:
-        span.set_attribute(GEN_AI_MEMORY_SCOPE, scope)
-
-    namespace = _namespace_from_kwargs(kwargs)
-    if namespace:
-        span.set_attribute(GEN_AI_MEMORY_NAMESPACE, namespace)
-
 
 def _set_error(span: trace.Span, exc: BaseException) -> str:
     """Record error details on the span and return the error type string."""
@@ -198,13 +163,11 @@ def wrapper(
             span_name, kind=SpanKind.CLIENT
         ) as span:
             _set_common_attributes(span, "update_memory", kwargs)
-            # Mem0 add() is an upsert
-            span.set_attribute(GEN_AI_MEMORY_UPDATE_STRATEGY, "merge")
 
             if _capture_content() and args:
                 messages = args[0] if args else kwargs.get("messages")
                 if messages and isinstance(messages, str):
-                    span.set_attribute(GEN_AI_MEMORY_CONTENT, messages)
+                    span.set_attribute(GEN_AI_MEMORY_RECORD_CONTENT, messages)
 
             try:
                 result = wrapped(*args, **kwargs)
@@ -221,7 +184,7 @@ def wrapper(
 
             mem_id = _first_memory_id(result)
             if mem_id:
-                span.set_attribute(GEN_AI_MEMORY_ID, mem_id)
+                span.set_attribute(GEN_AI_MEMORY_RECORD_ID, mem_id)
 
             return result
 
@@ -251,7 +214,7 @@ def wrapper(
 
             query = args[0] if args else kwargs.get("query")
             if _capture_content() and query and isinstance(query, str):
-                span.set_attribute(GEN_AI_MEMORY_QUERY, query)
+                span.set_attribute(GEN_AI_MEMORY_QUERY_TEXT, query)
 
             try:
                 result = wrapped(*args, **kwargs)
@@ -296,14 +259,13 @@ def wrapper(
             span_name, kind=SpanKind.CLIENT
         ) as span:
             _set_common_attributes(span, "update_memory", kwargs)
-            span.set_attribute(GEN_AI_MEMORY_UPDATE_STRATEGY, "overwrite")
             if memory_id:
-                span.set_attribute(GEN_AI_MEMORY_ID, str(memory_id))
+                span.set_attribute(GEN_AI_MEMORY_RECORD_ID, str(memory_id))
 
             if _capture_content():
                 data = kwargs.get("data")
                 if data and isinstance(data, str):
-                    span.set_attribute(GEN_AI_MEMORY_CONTENT, data)
+                    span.set_attribute(GEN_AI_MEMORY_RECORD_CONTENT, data)
 
             try:
                 result = wrapped(*args, **kwargs)
@@ -345,7 +307,7 @@ def wrapper(
         ) as span:
             _set_common_attributes(span, "delete_memory", kwargs)
             if memory_id:
-                span.set_attribute(GEN_AI_MEMORY_ID, str(memory_id))
+                span.set_attribute(GEN_AI_MEMORY_RECORD_ID, str(memory_id))
 
             try:
                 result = wrapped(*args, **kwargs)