monocle-apptrace 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

monocle_apptrace/README.md

@@ -1,37 +1,59 @@
-#Monocle User Guide
-
 ## Monocle Concepts
+
 ### Traces
-Traces are the full view of a single end-to-end application KPI eg Chatbot application to provide a response to end user’s question. Traces consists of various metadata about the application run including status, start time, duration, input/outputs etc. It also includes a list of individual steps aka “spans with details about that step.
-It’s typically the workflow code components of an application that generate the traces for application runs. 
+Traces are the full view of a single end-to-end application execution. 
+
+Examples of traces include one response to end user’s question by a chatbot app. Traces consists of various metadata about the application run including status, start time, duration, input/outputs etc. It also includes a list of individual steps aka “spans with details about that step.It’s typically the workflow code components of an application that generate the traces for application runs. 
+
+Traces are collections of spans. 
+
 ### Spans
-Spans are the individual steps executed by the application to perform a GenAI related task” eg app retrieving vectors from DB, app querying LLM for inference etc. The span includes the type of operation, start time, duration and metadata relevant to that step eg Model name, parameters and model endpoint/server for an inference request.
-It’s typically the workflow code components of an application that generate the traces for application runs.
+Spans are the individual steps executed by the application to perform a GenAI related task.
+
+Examples of spans include app retrieving vectors from DB, app querying LLM for inference etc. The span includes the type of operation, start time, duration and metadata relevant to that step eg Model name, parameters and model endpoint/server for an inference request.
 
-## Setup Monocle
-- You can download Monocle library releases from Pypi
+## Contribute to Monocle 
+
+Monocle includes:
+- Methods for instrumentation of app code 
+  - Base code for wrapping methods of interest in included in current folder
+  - Framework specific code is organized in a folder with the framework name
+- Metamodel for how attributes and events for GenAI components are represented in OpenTelemety format
+  - See [metamodel](./metamodel/README.md) for supported GenAI entities, how functions operating on those entities map to spans and format of spans 
+- Exporters to send trace data to various locations. See [exporters](./exporters)
+
+See [Monocle committer guide](/Monocle_committer_guide.md). 
+
+## Get Monocle
+
+Option 1 - Download released packages from Pypi
 ``` 
-    > python3 -m pip install pipenv
-    > pip install monocle-observability
+    python3 -m pip install pipenv
+    pip install monocle-apptrace
 ```
-- You can locally build and install Monocle library from source
+
+Option 2 - Build and install locally from source
 ```
-> pip install .
-> pip install -e ".[dev]"
+    pip install .
+    pip install -e ".[dev]"
 
-> python3 -m pip install pipenv
-> pipenv install build
+    python3 -m pip install pipenv
+    pipenv install build
 ```
 
-## Examples 
-### Enable Monocle tracing in your application
+## Examples of app instrumentation with Monocle
+ 
+### apps written using LLM orchestration frameworks 
+
 ```python
-from monocle_apptrace.instrumentor import setup_monocle_telemetry
-from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter
 from langchain.chains import LLMChain
 from langchain_openai import OpenAI
 from langchain.prompts import PromptTemplate
 
+# Import the monocle_apptrace instrumentation method 
+from monocle_apptrace.instrumentor import setup_monocle_telemetry
+from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter
+
 # Call the setup Monocle telemetry method
 setup_monocle_telemetry(workflow_name = "simple_math_app",
         span_processors=[BatchSpanProcessor(ConsoleSpanExporter())])
@@ -42,19 +64,19 @@ prompt = PromptTemplate.from_template("1 + {number} = ")
 chain = LLMChain(llm=llm, prompt=prompt)
 chain.invoke({"number":2})
 
-# Request callbacks: Finally, let's use the request `callbacks` to achieve the same result
-chain = LLMChain(llm=llm, prompt=prompt)
-chain.invoke({"number":2}, {"callbacks":[handler]})
-    
+# Trace is generated when invoke() method is called
+
 ```
 
-### Monitoring custom methods with Monocle
+### apps with custom methods
 
 ```python
+
+# Import the monocle_apptrace instrumentation method
 from monocle_apptrace.wrapper import WrapperMethod,task_wrapper,atask_wrapper
 from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter
 
-# extend the default wrapped methods list as follows
+# Extend the default wrapped methods list as follows
 app_name = "simple_math_app"
 setup_monocle_telemetry(
         workflow_name=app_name,
@@ -74,4 +96,6 @@ setup_monocle_telemetry(
                 wrapper=atask_wrapper)
         ])
 
-```
+# Trace is generated when the invoke() method is called in langchain.schema.runnable package
+
+```

monocle_apptrace/haystack/__init__.py

@@ -6,4 +6,4 @@ from monocle_apptrace.utils import load_wrapper_from_config
 logger = logging.getLogger(__name__)
 parent_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
 HAYSTACK_METHODS = load_wrapper_from_config(
-    os.path.join(parent_dir, 'wrapper_config', 'haystack_methods.json'))
+    os.path.join(parent_dir, 'metamodel', 'maps', 'haystack_methods.json'))

monocle_apptrace/haystack/wrap_pipeline.py

@@ -5,6 +5,7 @@ from opentelemetry.instrumentation.utils import (
     _SUPPRESS_INSTRUMENTATION_KEY,
 )
 from monocle_apptrace.wrap_common import PROMPT_INPUT_KEY, PROMPT_OUTPUT_KEY, WORKFLOW_TYPE_MAP, with_tracer_wrapper
+from monocle_apptrace.utils import set_embedding_model
 
 logger = logging.getLogger(__name__)
 
@@ -17,6 +18,9 @@ def wrap(tracer, to_wrap, wrapped, instance, args, kwargs):
     attach(set_value("workflow_name", name))
     inputs = set()
     workflow_input = get_workflow_input(args, inputs)
+    embedding_model = get_embedding_model(instance)
+    set_embedding_model(embedding_model)
+
 
     with tracer.start_as_current_span(f"{name}.workflow") as span:
         span.set_attribute(PROMPT_INPUT_KEY, workflow_input)
@@ -44,3 +48,15 @@ def get_workflow_input(args, inputs):
 def set_workflow_attributes(span, workflow_name):
     span.set_attribute("workflow_name",workflow_name)
     span.set_attribute("workflow_type", WORKFLOW_TYPE_MAP["haystack"])
+
+def get_embedding_model(instance):
+    try:
+        if hasattr(instance, 'get_component'):
+            text_embedder = instance.get_component('text_embedder')
+            if text_embedder and hasattr(text_embedder, 'model'):
+                # Set the embedding model attribute
+                return text_embedder.model
+    except:
+        pass
+
+    return None

monocle_apptrace/instrumentor.py

@@ -11,7 +11,7 @@ from opentelemetry.sdk.trace.export import BatchSpanProcessor, SpanProcessor
 from opentelemetry.sdk.resources import SERVICE_NAME, Resource
 from opentelemetry import trace
 from opentelemetry.context import get_value, attach, set_value
-from monocle_apptrace.wrap_common import CONTEXT_PROPERTIES_KEY
+from monocle_apptrace.wrap_common import SESSION_PROPERTIES_KEY
 from monocle_apptrace.wrapper import INBUILT_METHODS_LIST, WrapperMethod
 from monocle_apptrace.exporters.file_exporter import FileSpanExporter
 
@@ -113,12 +113,12 @@ def setup_monocle_telemetry(
 
 
 def on_processor_start(span: Span, parent_context):
-    context_properties = get_value(CONTEXT_PROPERTIES_KEY)
+    context_properties = get_value(SESSION_PROPERTIES_KEY)
     if context_properties is not None:
         for key, value in context_properties.items():
             span.set_attribute(
-                f"{CONTEXT_PROPERTIES_KEY}.{key}", value
+                f"{SESSION_PROPERTIES_KEY}.{key}", value
             )
 
 def set_context_properties(properties: dict) -> None:
-    attach(set_value(CONTEXT_PROPERTIES_KEY, properties))
+    attach(set_value(SESSION_PROPERTIES_KEY, properties))

monocle_apptrace/langchain/__init__.py

@@ -3,4 +3,4 @@ from monocle_apptrace.utils import load_wrapper_from_config
 
 parent_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
 LANGCHAIN_METHODS = load_wrapper_from_config(
-    os.path.join(parent_dir, 'wrapper_config', 'lang_chain_methods.json'))
+    os.path.join(parent_dir, 'metamodel', 'maps', 'lang_chain_methods.json'))

monocle_apptrace/llamaindex/__init__.py

@@ -12,4 +12,4 @@ def get_llm_span_name_for_openai(instance):
 
 parent_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
 LLAMAINDEX_METHODS = load_wrapper_from_config(
-    os.path.join(parent_dir, 'wrapper_config', 'llama_index_methods.json'))
+    os.path.join(parent_dir, 'metamodel', 'maps', 'llama_index_methods.json'))

monocle_apptrace/metamodel/README.md

@@ -0,0 +1,47 @@
+# Monocle metamodel
+
+## Overview 
+Monocle metamodel is the way to manage standardization across all supported GenAI component stack. It includes the list of components that Monocle can identify and extract metadata. This help understanding and analyzing the traces from applications that include multiple components and can evolve over time. This is one of core value that Monocle provides to it's user community.
+
+## Meta model
+The Monocle metamodel comprises of three things, 
+- Entity types, definitions of technology types and supported vendor implementations.
+- A JSON format that overlays on top of Open Telemetry tracing format that includes the common attributes for each entity type.
+- Map of component menthods to trace with instrumentation methods provided by Monocle.
+
+### Entity type
+The entity type defines the type of GenAI component that Monocle understand. The monocle instrumentation can extract the relevenat information for this entity. There are a fixed set of [entity types](./entity_types.py) that are defined by Monocle out of the box, eg workflow, model etc. As the GenAI landscape evolves, the Monocle community will introduce a new entity type if the current entities won't represent a new technology component.
+Each entity types has number of supported technology components that Monocle handles out of the box, eg. LlamaIndex is a supported workflow. Monocle community will continue to expand the breadth of the project by adding more components.
+
+### Span types
+The GenAI application have specific [types of spans](./spans/README.md#span-types-and-events) where diffrent entities integrate. Monocle metamodel defines these types and specifies format for tracing data and metadata generated in such spans. 
+
+### Consistent trace format
+Monocle generates [traces](../../../Monocle_User_Guide.md#traces) which comprises of [spans](../../../Monocle_User_Guide.md#spans). Note that Monocle trace is [OpenTelemetry format](https://opentelemetry.io/docs/concepts/signals/traces/) compatible. Each span is essentially a step in the execution that interacts with one of more GenAI technology components. The please refer to the [full spec of the json format](./span_format.json) and a detailed [example](./span_example.json). 
+The ```attribute``` section of the span includes a list of such entities that are used in that span.
+The runtime data and metadata collected during the execution of that span are included in the ```events``` section of the trace (as per the Otel spec). Each entry in the event corrosponds to the entity involved in that trace execution if it has produced any runtime outputs. 
+Please see the [span format](./spans/README.md) for details.
+
+### Instrumentation method map
+The map dectates what Monocle tracing method is relevant for the a given GenAI tech component method/API. It also specifies the name for that span to set in the trace output.
+```python
+    {
+        "package": "llama_index.core.base.base_query_engine",
+        "object": "BaseQueryEngine",
+        "method": "query",
+        "span_name": "llamaindex.query",
+        "wrapper_package": "wrap_common",
+        "wrapper_method": "task_wrapper"
+    }
+```
+
+## Extending the meta model
+Monocle is highly extensible. This section describe when one would need to extend the meta model. Please refer to Monocle [User guide](../../../Monocle_User_Guide.md) and [Contributor guide](../../../Monocle_contributor_guide.md) for detailed steps.
+### Trace a new method/API
+If you have overloaded an existing functionality in one of the supported components by creating a new function. Monocle doesn't know that this function should be traced, say because it's calling an LLM. You could define a new mapping so Monocle instrumentation can trace this function the say way it handles other LLM invocation functions.
+
+### Adding a new component provider
+Let's say there's a new database that supports vector search capability which is not supported by the Monocle. In this case, first you'll need to add that database under the ``MonocleEntity.VectorDB`` list. Then you'll need to extend the method map and test if the existing Monocle tracing functions has logic to effectively trace the new component. If not, then you might need to implement new method to cover the gap and update the mapping table according.
+
+### Support new type of entity
+If there's new component that can't be mapped to any of the existing entity types, then it'll require extending the metamodel and implement new instrumetation to support it. We recommend you initiate a discussion with Monocle community to add the support.

monocle_apptrace/metamodel/entities/README.md

@@ -0,0 +1,54 @@
+# Monocle Entities
+The entity type defines the type of GenAI component that Monocle understand. The monocle instrumentation can extract the relevenat information for this entity. There are a fixed set of [entity types](./entity_types.py) that are defined by Monocle out of the box, eg workflow, model etc. As the GenAI landscape evolves, the Monocle community will introduce a new entity type if the current entities won't represent a new technology component.
+
+## Entity Types
+Following attributes are supported for all entities
+| Name | Description | Required |
+| - | - | - |
+| name | Entity name generated by Monocle | Required |
+| type | Monocle Entity type | True |
+
+### MonocleEntity.Workflow
+Workflow ie the core application code. Supported types are -
+- generic
+- langchain
+- llama_index
+- haystack
+
+### MonocleEntity.Model
+GenAI models. Supported types are -
+- generic
+- llm
+- embedding
+Following attributes are supported for all model type entities
+| Name | Description | Required |
+| - | - | - |
+| model_name | Name of model | True |
+
+
+### MonocleEntity.AppHosting
+Application host services where the workflow code is run. Supported types are -
+- generic
+- aws_lambda
+- aws_sagemaker
+- azure_func
+- github_codespace
+- azure_mlw
+
+### MonocleEntity.Inference
+The model hosting infrastructure services. Supported types are -
+- generic
+- nvidia_triton
+- openai
+- azure_oai
+- aws_sagemaker
+- aws_bedrock
+- hugging_face
+
+### MonocleEntity.VectorStore
+Vector search data stores. Supported types are -
+- generic
+- chroma
+- aws_es
+- milvus
+- pinecone

monocle_apptrace/metamodel/entities/entity_types.json

@@ -0,0 +1,157 @@
+{
+    "description": "Monocle entities represents kinds GenAI technology components and their implementations supported by Monocle",
+    "monocle_entities": [
+        {
+            "attributes" : [
+                {
+                    "attribute_name": "name",
+                    "attribute_description": "Monocle entity name",
+                    "required": true
+                },
+                {
+                    "attribute_name": "type",
+                    "attribute_description": "Monocle entity type",
+                    "required": true
+                }
+            ],
+            "entities": [
+                {
+                    "name": "workflow",
+                    "attributes" : [],
+                    "types": [
+                        {
+                            "type": "llama_index",
+                            "attributes" : []
+                        },
+                        {
+                            "type": "langchain",
+                            "attributes" : []
+                        },
+                        {
+                            "type": "haystack",
+                            "attributes" : []
+                        },
+                        {
+                            "type": "generic",
+                            "attributes" : []
+                        }
+                    ]
+                },
+                {
+                    "name": "model",
+                    "attributes" : [
+                        {
+                            "attribute_name": "model_name",
+                            "attribute_description": "Model name",
+                            "required": true
+                        }
+                    ],
+                    "types": [
+                        {
+                            "type": "llm",
+                            "attributes" : []
+                        },
+                        {
+                            "type": "embedding",
+                            "attributes" : []
+                        },
+                        {
+                            "type": "generic",
+                            "attributes" : []
+                        }
+                    ]
+                },
+                {
+                    "name": "vector_store",
+                    "attributes" : [],
+                    "types": [
+                        {
+                            "type": "chroma",
+                            "attributes" : []
+                        },
+                        {
+                            "type": "aws_es",
+                            "attributes" : []
+                        },
+                        {
+                            "type": "milvus",
+                            "attributes" : []
+                        },
+                        {
+                            "type": "pinecone",
+                            "attributes" : []
+                        },
+                        {
+                            "type": "generic",
+                            "attributes" : []
+                        }
+                    ]
+                },
+                {
+                    "name": "app_hosting",
+                    "attributes" : [],
+                    "types": [
+                        {
+                            "type": "aws_lambda",
+                            "attributes" : []
+                        },
+                        {
+                            "type": "aws_sagemaker",
+                            "attributes" : []
+                        },
+                        {
+                            "type": "azure_func",
+                            "attributes" : []
+                        },
+                        {
+                            "type": "azure_mlw",
+                            "attributes" : []
+                        },
+                        {
+                            "type": "github_codespace",
+                            "attributes" : []
+                        },
+                        {
+                            "type": "generic",
+                            "attributes" : []
+                        }
+                    ]
+                },
+                {
+                    "name": "inference",
+                    "attributes" : [],
+                    "types": [
+                        {
+                            "type": "aws_sagemaker",
+                            "attributes" : []
+                        },
+                        {
+                            "type": "aws_bedrock",
+                            "attributes" : []
+                        },
+                        {
+                            "type": "azure_oai",
+                            "attributes" : []
+                        },
+                        {
+                            "type": "openai",
+                            "attributes" : []
+                        },
+                        {
+                            "type": "nvidia_triton",
+                            "attributes" : []
+                        },
+                        {
+                            "type": "hugging_face",
+                            "attributes" : []
+                        },
+                        {
+                            "type": "generic",
+                            "attributes" : []
+                        }
+                    ]
+                }
+            ]
+        }  
+    ]
+}

monocle_apptrace/metamodel/entities/entity_types.py

@@ -0,0 +1,51 @@
+# Monocle meta model:
+# Monocle Entities --> Entity Type --> Entity
+
+import enum
+
+class MonocleEntity(enum):
+    # Supported Workflow/language frameworks
+    class Workflow(enum):
+        generic = 0
+        langchain = 1
+        llama_index = 2
+        haystack = 3
+
+    # Supported model types
+    class Model(enum):
+        generic = 0
+        llm = 1
+        embedding = 2
+
+    # Support Vector databases
+    class VectorStore(enum):
+        generic = 0
+        chroma = 1
+        aws_es = 2
+        Milvus = 3
+        Pinecone = 4
+
+    # Support application hosting frameworks
+    class AppHosting(enum):
+        generic = 0
+        aws_lambda = 1
+        aws_sagemaker = 2
+        azure_func = 3
+        github_codespace = 4
+        azure_mlw = 5
+
+    # Supported inference infra/services
+    class Inference(enum):
+        generic = 0
+        nvidia_triton = 1
+        openai = 2
+        azure_oai = 3
+        aws_sagemaker = 4
+        aws_bedrock = 5
+        hugging_face = 6
+
+class SpanType(enum):
+    internal = 0
+    retrieval = 2
+    inference = 3
+    workflow = 4

monocle_apptrace/metamodel/spans/README.md

@@ -0,0 +1,121 @@
+# Monocle Span format
+Monocle generates [traces](../../../../Monocle_User_Guide.md#traces) which comprises of [spans](../../../../Monocle_User_Guide.md#spans). Note that Monocle trace is [OpenTelemetry format](https://opentelemetry.io/docs/concepts/signals/traces/) compatible. Each span is essentially a step in the execution that interacts with one of more GenAI technology components. This document explains the [span format](./span_format.json) that Monocle generates for GenAI application tracing.
+
+Per the OpenTelemetry convention, each span contains an attribute section and event section. In Monocle generated trace, the attribute sections includes details of GenAI entities used in the span. The event section includes the input, output and metadata related to the execution of that span.
+
+## Attributes 
+The attribute sections includes details of GenAI entities used in the span. For each entity used in the span in includes the entity name and entity type. For every type of entity, there are required and optional attributes listed below.
+### Json format
+```json
+    attributes: 
+        "span.type": "Monocle-span-type",
+        "entity.count": "count-of-entities",
+    
+        "entity.<index>.name": "Monocle-Entity-name",
+        "entity.<index>.type": "MonocleEntity.<entity-type>"
+        ...
+```
+The ```entity.count``` indicates total number of entities used in the given span. For each entity, the details are captured in ```entity.<index>.X```. For example, 
+```json
+    "attributes": {
+        "span.type": "Inference",
+        "entity.count": 2,
+        "entity.1.name": "AzureOpenAI",
+        "entity.1.type": "Inference.Azure_oai",
+        "entity.2.name": "gpt-35-turbo",
+        "entity.2.type": "Model.LLM",
+        "entity.2.model_name": "gpt-35-turbo",
+```
+
+### Entity type specific attributes
+#### MonocleEntity.Workflow
+| Name | Description | Values | Required |
+| - | - | - | - |
+| name | Entity name generated by Monocle | Name String | Required |
+| type | Monocle Entity type | MonocleEntity.Workflow | Required |
+| optional-attribute | Additional attribute specific to entity |  | Optional |
+
+### MonocleEntity.Model
+| Name | Description | Values | Required |
+| - | - | - | - |
+| name | Entity name generated by Monocle | Name String | Required |
+| type | Monocle Entity type | MonocleEntity.Model | Required |
+| model_name | Name of model | String | Required |
+| optional-attribute | Additional attribute specific to entity |  | Optional |
+
+### MonocleEntity.AppHosting
+| Name | Description | Values | Required |
+| - | - | - | - |
+| name | Entity name generated by Monocle | Name String | Required |
+| type | Monocle Entity type | MonocleEntity.AppHosting | Required |
+| optional-attribute | Additional attribute specific to entity |  | Optional |
+
+### MonocleEntity.Inference
+| Name | Description | Values | Required |
+| - | - | - | - |
+| name | Entity name generated by Monocle | Name String | Required |
+| type | Monocle Entity type | MonocleEntity.Inference | Required |
+| optional-attribute | Additional attribute specific to entity |  | Optional |
+
+### MonocleEntity.VectorDB
+| Name | Description | Values | Required |
+| - | - | - | - |
+| name | Entity name generated by Monocle | Name String | Required |
+| type | Monocle Entity type | MonocleEntity.VectorDB | Required |
+| optional-attribute | Additional attribute specific to entity |  | Optional |
+
+## Events
+The event section includes the input, output and metadata generated by that span execution. For each type of span, there are required and option input, output and metadata items listed below. If there's no data genearated in the space, the events will be an empty array.
+
+### Json format
+```json
+    "events" : [
+        {
+            "name": "data.input",
+            "timestamp": "UTC timestamp",
+            "attributes": {
+                "input_attribute": "value"
+           }
+        },
+        {
+            "name": "data.output",
+            "timestamp": "UTC timestamp",
+            "attributes": {
+                "output_attribute": "value"
+            }
+        },
+        {
+            "name": "metadata",
+            "timestamp": "UTC timestamp",
+            "attributes": {
+                "metadata_attribute": "value"
+            }
+        }
+    ]
+```
+
+## Span types and events
+The ```span.type``` captured in ```attributes``` section of the span dectates the format of the ```events```
+### SpanType.Retrieval
+| Name | Description | Values | Required |
+| - | - | - | - |
+| name | event name  | data.input or data.output or metadata | Required |
+| timestamp | timestap when the event occurred | UTC timestamp | Required |
+| attributes | input/output/metadata attributes generated in span | Dictionary | Required |
+
+### SpanType.Inference
+| Name | Description | Values | Required |
+| - | - | - | - |
+| name | event name  | data.input or data.output or metadata | Required |
+| timestamp | timestap when the event occurred | UTC timestamp | Required |
+| attributes | input/output/metadata attributes generated in span | Dictionary | Required |
+
+### SpanType.Workflow
+| Name | Description | Values | Required |
+| - | - | - | - |
+| name | event name  | data.input or data.output or metadata | Required |
+| timestamp | timestap when the event occurred | UTC timestamp | Required |
+| attributes | input/output/metadata attributes generated in span | Dictionary | Required |
+
+### SpanType.Internal
+Events will be empty

monocle_apptrace/metamodel/spans/span_example.json

@@ -0,0 +1,140 @@
+{
+    "name": "llamaindex.retrieve",
+    "context": {
+        "trace_id": "0x93cd0bf865b3ffcc3cf9c075dc3e3797",
+        "span_id": "0x5d3f839e900bda24",
+        "trace_state": "[]"
+    },
+    "kind": "SpanKind.CLIENT",
+    "parent_id": "0x7a63d63e42ccac60",
+    "start_time": "2024-09-09T14:38:45.237182Z",
+    "end_time": "2024-09-09T14:38:45.620112Z",
+    "status": {
+        "status_code": "OK"
+    },
+    "attributes": {
+        "span.type": "Retrieval", 
+        "entity.count": 2,
+        "entity.1.name": "ChromaVectorStore",
+        "entity.1.type": "vectorstore.chroma",
+        "entity.1.embedding-model-name": "BAAI/bge-small-en-v1.5",
+        "entity.2.name": "BAAI/bge-small-en-v1.5",
+        "entity.2.type": "model.embedding",
+        "entity.2.model_name": "BAAI/bge-small-en-v1.5"
+    },
+    "events": [
+        {
+            "name": "data.input",
+            "timestamp": "timestamp",
+            "attributes": {
+                "context_input": "question: What is an americano?"
+            }
+        },
+        {
+            "name": "data.output",
+            "timestamp": "timestamp",
+            "attributes": {
+                "context_output": "Coffee is a hot drink made from the roasted and ground seeds (coffee beans) of a tropical shrub\nA latte consists of one or more shots of espresso, served in a glass (or sometimes a cup), into which hot steamed milk is added\nAmericano is a type of coffee drink prepared by diluting an espresso shot with hot water at a 1:3 to 1:4 ratio, resulting in a drink that retains the complex flavors of espresso, but in a lighter way"
+            }
+        }
+
+    ],
+    "links": [],
+    "resource": {
+        "attributes": {
+            "service.name": "coffee-bot"
+        },
+        "schema_url": ""
+    }
+},
+{
+    "name": "llamaindex.openai",
+    "context": {
+        "trace_id": "0x93cd0bf865b3ffcc3cf9c075dc3e3797",
+        "span_id": "0x8b6363e1937a4d7b",
+        "trace_state": "[]"
+    },
+    "kind": "SpanKind.CLIENT",
+    "parent_id": "0x7a63d63e42ccac60",
+    "start_time": "2024-09-09T14:38:45.622174Z",
+    "end_time": "2024-09-09T14:38:46.514120Z",
+    "status": {
+        "status_code": "OK"
+    },
+    "attributes": {
+        "span.type": "inference",
+        "entity.count": 2,
+        "entity.1.name": "AzureOpenAI",
+        "entity.1.type": "inference.azure_oai",
+        "entity.1.provider_name": "openai.azure.com",
+        "entity.1.deployment": "kshitiz-gpt",
+        "entity.1.inference_endpoint": "https://okahu-openai-dev.openai.azure.com/",
+
+        "entity.2.name": "gpt-35-turbo",
+        "entity.2.type": "model.llm",
+        "entity.2.model_name": "gpt-35-turbo"
+    },
+    "events": [
+        {
+            "name": "data.input",
+            "timestamp": "timestamp",
+            "attributes": {
+                "question": "What is an americano?",
+            }
+        },
+        {
+            "name": "data.output",
+            "timestamp": "timestamp",
+            "attributes": {
+                "response": "An americano is a type of coffee drink that is made by diluting an espresso shot with hot water at a 1:3 to 1:4 ratio, resulting in a drink that retains the complex flavors of espresso, but in a lighter way.",
+            }
+        },
+        {
+            "name": "metadata",
+            "timestamp": "timestamp",
+            "attributes": {
+                "temperature": 0.1,
+                "completion_tokens": 52,
+                "prompt_tokens": 233,
+                "total_tokens": 285
+            }
+        }
+    ],
+    "links": [],
+    "resource": {
+        "attributes": {
+            "service.name": "coffee-bot"
+        },
+        "schema_url": ""
+    }
+}
+{
+    "name": "llamaindex.query",
+    "context": {
+        "trace_id": "0x93cd0bf865b3ffcc3cf9c075dc3e3797",
+        "span_id": "0x7a63d63e42ccac60",
+        "trace_state": "[]"
+    },
+    "kind": "SpanKind.CLIENT",
+    "parent_id": null,
+    "start_time": "2024-09-09T14:38:45.236627Z",
+    "end_time": "2024-09-09T14:38:46.514442Z",
+    "status": {
+        "status_code": "OK"
+    },
+    "attributes": {
+        "span.type": "workflow",
+        "entity.count": 1,
+        "entity.1.name": "coffee-bot",
+        "entity.1.type": "workflow.llama_index"
+    },
+    "events": [
+    ],
+    "links": [],
+    "resource": {
+        "attributes": {
+            "service.name": "coffee-bot"
+        },
+        "schema_url": ""
+    }
+}

monocle_apptrace/metamodel/spans/span_format.json

@@ -0,0 +1,55 @@
+{
+    "name": "span-name",
+    "context": {
+        "trace_id": "trace-id",
+        "span_id": "span-id",
+        "trace_state": "[]"
+    },
+    "kind": "SpanKind.CLIENT",
+    "parent_id": "parent-id or None (for root span)",
+    "start_time": "UTC timestamp",
+    "end_time": "UTC timestamp",
+    "status": {
+        "status_code": "OK or Error"
+    },
+    "attributes": {
+        "description": "List of AI component entities used in this span, eg Model, Inference hosting service. Needs to be one of the supported entity types.",
+    
+        "span.type": "Monocle-span-type",
+        "entity.count": "count-of-entities",
+    
+        "entity.<index>.name": "Monocle-Entity-name",
+        "entity.<index>.type": "Monocle-Entity-Type",
+        "entity.<index>.<attribute>": "Value"
+    },
+    "events" : [
+        {
+            "name": "data.input",
+            "timestamp": "UTC timestamp",
+            "attributes": {
+                "input_attribute": "value"
+           }
+        },
+        {
+            "name": "data.output",
+            "timestamp": "UTC timestamp",
+            "attributes": {
+                "output_attribute": "value"
+            }
+        },
+        {
+            "name": "metadata",
+            "timestamp": "UTC timestamp",
+            "attributes": {
+                "metadata_attribute": "value"
+            }
+        }
+    ],
+    "links": [],
+    "resource": {
+        "attributes": {
+            "service.name": "top-workflow-name"
+        },
+        "schema_url": ""
+    }
+}

monocle_apptrace/utils.py

@@ -5,6 +5,8 @@ import os
 from opentelemetry.trace import Span
 from monocle_apptrace.constants import azure_service_map, aws_service_map
 
+embedding_model_context = {}
+
 def set_span_attribute(span, name, value):
     if value is not None:
         if value != "":
@@ -71,3 +73,21 @@ def update_span_with_infra_name(span: Span, span_key: str):
     for key,val  in aws_service_map.items():
         if key in os.environ:
             span.set_attribute(span_key, val)
+
+
+def set_embedding_model(model_name: str):
+    """
+    Sets the embedding model in the global context.
+
+    @param model_name: The name of the embedding model to set
+    """
+    embedding_model_context['embedding_model'] = model_name
+
+
+def get_embedding_model() -> str:
+    """
+    Retrieves the embedding model from the global context.
+
+    @return: The name of the embedding model, or 'unknown' if not set
+    """
+    return embedding_model_context.get('embedding_model', 'unknown')

monocle_apptrace/wrap_common.py

@@ -4,7 +4,7 @@ import os
 from urllib.parse import urlparse
 
 from opentelemetry.trace import Span, Tracer
-from monocle_apptrace.utils import resolve_from_alias, update_span_with_infra_name, with_tracer_wrapper
+from monocle_apptrace.utils import resolve_from_alias, update_span_with_infra_name, with_tracer_wrapper, get_embedding_model
 
 logger = logging.getLogger(__name__)
 WORKFLOW_TYPE_KEY = "workflow_type"
@@ -15,9 +15,12 @@ PROMPT_OUTPUT_KEY = "output"
 QUERY = "question"
 RESPONSE = "response"
 TAGS = "tags"
-CONTEXT_PROPERTIES_KEY = "workflow_context_properties"
+SESSION_PROPERTIES_KEY = "session"
 INFRA_SERVICE_KEY = "infra_service_name"
-
+TYPE = "type"
+PROVIDER = "provider_name"
+EMBEDDING_MODEL = "embedding_model"
+VECTOR_STORE = 'vector_store'
 
 
 WORKFLOW_TYPE_MAP = {
@@ -26,6 +29,24 @@ WORKFLOW_TYPE_MAP = {
     "haystack": "workflow.haystack"
 }
 
+framework_vector_store_mapping = {
+    'langchain_core.retrievers': lambda instance: {
+        'provider': instance.tags[0],
+        'embedding_model': instance.tags[1],
+        'type': VECTOR_STORE,
+    },
+    'llama_index.core.indices.base_retriever': lambda instance: {
+        'provider': type(instance._vector_store).__name__,
+        'embedding_model': instance._embed_model.model_name,
+        'type': VECTOR_STORE,
+    },
+    'haystack.components.retrievers': lambda instance: {
+        'provider': instance.__dict__.get("document_store").__class__.__name__,
+        'embedding_model': get_embedding_model(),
+        'type': VECTOR_STORE,
+    },
+}
+
 @with_tracer_wrapper
 def task_wrapper(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs):
     """Instruments and calls every function defined in TO_WRAP."""
@@ -66,6 +87,7 @@ def pre_task_processing(to_wrap, instance, args, span):
     #capture the tags attribute of the instance if present, else ignore
     try:
         update_tags(instance, span)
+        update_vectorstore_attributes(to_wrap, instance, span)
     except AttributeError:
         pass
     update_span_with_context_input(to_wrap=to_wrap, wrapped_args=args, span=span)
@@ -133,6 +155,8 @@ def llm_wrapper(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs):
     else:
         name = f"langchain.task.{instance.__class__.__name__}"
     with tracer.start_as_current_span(name) as span:
+        if 'haystack.components.retrievers' in to_wrap['package'] and 'haystack.retriever' in span.name:
+            update_vectorstore_attributes(to_wrap, instance, span)
         update_llm_endpoint(curr_span= span, instance=instance)
 
         return_value = wrapped(*args, **kwargs)
@@ -148,12 +172,12 @@ def update_llm_endpoint(curr_span: Span, instance):
         if 'temperature' in instance.__dict__:
             temp_val = instance.__dict__.get("temperature")
             curr_span.set_attribute("temperature", temp_val)
-        # handling for model name
-        model_name =  resolve_from_alias(instance.__dict__ , ["model","model_name"])
+            # handling for model name
+        model_name = resolve_from_alias(instance.__dict__ , ["model","model_name"])
         curr_span.set_attribute("model_name", model_name)
         set_provider_name(curr_span, instance)
         # handling AzureOpenAI deployment
-        deployment_name =  resolve_from_alias(instance.__dict__ , [ "engine", "azure_deployment",
+        deployment_name = resolve_from_alias(instance.__dict__ , [ "engine", "azure_deployment",
                                                                    "deployment_name", "deployment_id", "deployment"])
         curr_span.set_attribute("az_openai_deployment", deployment_name)
         # handling the inference endpoint
@@ -191,7 +215,6 @@ def get_input_from_args(chain_args):
     return ""
 
 def update_span_from_llm_response(response, span: Span):
-    
     # extract token uasge from langchain openai
     if (response is not None and hasattr(response, "response_metadata")):
         response_metadata = response.response_metadata
@@ -266,3 +289,23 @@ def update_tags(instance, span):
         span.set_attribute(TAGS, [model_name, vector_store_name])
     except:
         pass
+
+
+def update_vectorstore_attributes(to_wrap, instance, span):
+    """
+       Updates the telemetry span attributes for vector store retrieval tasks.
+    """
+    try:
+        package = to_wrap.get('package')
+        if package in framework_vector_store_mapping:
+            attributes = framework_vector_store_mapping[package](instance)
+            span._attributes.update({
+                TYPE: attributes['type'],
+                PROVIDER: attributes['provider'],
+                EMBEDDING_MODEL: attributes['embedding_model']
+            })
+        else:
+            logger.warning(f"Package '{package}' not recognized for vector store telemetry.")
+
+    except Exception as e:
+        logger.error(f"Error updating span attributes: {e}")

monocle_apptrace-0.1.1.dist-info/METADATA

@@ -0,0 +1,111 @@
+Metadata-Version: 2.3
+Name: monocle_apptrace
+Version: 0.1.1
+Summary: package with monocle genAI tracing
+Project-URL: Homepage, https://github.com/monocle2ai/monocle
+Project-URL: Issues, https://github.com/monocle2ai/monocle/issues
+License-File: LICENSE
+License-File: NOTICE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Requires-Dist: opentelemetry-api>=1.21.0
+Requires-Dist: opentelemetry-instrumentation
+Requires-Dist: opentelemetry-sdk>=1.21.0
+Requires-Dist: requests
+Requires-Dist: wrapt>=1.14.0
+Provides-Extra: dev
+Requires-Dist: datasets==2.20.0; extra == 'dev'
+Requires-Dist: faiss-cpu==1.8.0; extra == 'dev'
+Requires-Dist: instructorembedding==1.0.1; extra == 'dev'
+Requires-Dist: langchain-chroma==0.1.1; extra == 'dev'
+Requires-Dist: langchain-community==0.2.5; extra == 'dev'
+Requires-Dist: langchain-openai==0.1.8; extra == 'dev'
+Requires-Dist: langchain==0.2.5; extra == 'dev'
+Requires-Dist: llama-index-embeddings-huggingface==0.2.0; extra == 'dev'
+Requires-Dist: llama-index-vector-stores-chroma==0.1.9; extra == 'dev'
+Requires-Dist: llama-index==0.10.30; extra == 'dev'
+Requires-Dist: numpy==1.26.4; extra == 'dev'
+Requires-Dist: parameterized==0.9.0; extra == 'dev'
+Requires-Dist: pytest==8.0.0; extra == 'dev'
+Requires-Dist: sentence-transformers==2.6.1; extra == 'dev'
+Requires-Dist: types-requests==2.31.0.20240106; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Monocle for tracing GenAI app code
+
+**Monocle** helps developers and platform engineers building or managing GenAI apps monitor these in prod by making it easy to instrument their code to capture traces that are compliant with open-source cloud-native observability ecosystem. 
+
+**Monocle** is a community-driven OSS framework for tracing GenAI app code governed as a [Linux Foundation AI & Data project](https://lfaidata.foundation/projects/monocle/). 
+
+## Why Monocle
+
+Monocle is built for: 
+- **app developers** to trace their app code in any environment without lots of custom code decoration 
+- **platform engineers** to instrument apps in prod through wrapping instead of asking app devs to recode
+- **GenAI component providers** to add observability features to their products 
+- **enterprises** to consume traces from GenAI apps in their existing open-source observability stack
+
+Benefits:
+- Monocle provides an implementation + package, not just a spec 
+   - No expertise in OpenTelemetry spec required
+   - No bespoke implementation of that spec required
+   - No last-mile GenAI domain specific code required to instrument your app
+- Monocle provides consistency  
+   - Connect traces across app code executions, model inference or data retrievals
+   - No cleansing of telemetry data across GenAI component providers required
+   - Works the same in personal lab dev or org cloud prod environments
+   - Send traces to location that fits your scale, budget and observability stack
+- Monocle is fully open source and community driven
+   - No vendor lock-in
+   - Implementation is transparent
+   - You can freely use or customize it to fit your needs 
+
+## What Monocle provides
+
+- Easy to [use](#use-monocle) code instrumentation
+- OpenTelemetry compatible format for [spans](src/monocle_apptrace/metamodel/spans/span_format.json). 
+- Community-curated and extensible [metamodel](src/monocle_apptrace/metamodel/README.md) for consisent tracing of GenAI components. 
+- Export to local and cloud storage 
+
+## Use Monocle
+
+- Get the Monocle package
+  
+```
+    pip install monocle_apptrace 
+```
+- Instrument your app code
+     - Import the Monocle package
+       ```
+          from monocle_apptrace.instrumentor import setup_monocle_telemetry
+       ```
+     - Setup instrumentation in your ```main()``` function  
+       ``` 
+          setup_monocle_telemetry(workflow_name="your-app-name")
+       ```         
+- (Optionally) Modify config to alter where traces are sent
+
+See [Monocle user guide](Monocle_User_Guide.md) for more details.
+  
+
+## Roadmap 
+
+Goal of Monocle is to support tracing for apps written in *any language* with *any LLM orchestration or agentic framework* and built using models, vectors, agents or other components served up by *any cloud or model inference provider*. 
+
+Current version supports: 
+- Language: (🟢) Python , (🔜) [Typescript](https://github.com/monocle2ai/monocle-typescript) 
+- LLM-frameworks: (🟢) Langchain, (🟢) Llamaindex, (🟢) Haystack, (🔜) Flask
+- LLM inference providers: (🟢) OpenAI, (🟢) Azure OpenAI, (🟢) Nvidia Triton, (🔜) AWS Bedrock, (🔜) Google Vertex, (🔜) Azure ML, (🔜) Hugging Face
+- Vector stores: (🟢) FAISS, (🔜) OpenSearch, (🔜) Milvus
+- Exporter: (🟢) stdout, (🟢) file, (🔜) Azure Blob Storage, (🔜) AWS S3, (🔜) Google Cloud Storage
+
+
+## Get involved
+### Provide feedback
+- Submit issues and enhancements requests via Github issues
+
+### Contribute
+- Monocle is community based open source project. We welcome your contributions. Please refer to the CONTRIBUTING and CODE_OF_CONDUCT for guidelines. The [contributor's guide](CONTRIBUTING.md) provides technical details of the project.
+

monocle_apptrace-0.1.1.dist-info/RECORD

@@ -0,0 +1,29 @@
+monocle_apptrace/README.md,sha256=T5NFC01bF8VR0oVnAX_n0bhsEtttwqfTxDNAe5Y_ivE,3765
+monocle_apptrace/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+monocle_apptrace/constants.py,sha256=wjObbmMTFL201x-bf3EOXevYygwkFH_1ng5dDrpE3z0,810
+monocle_apptrace/instrumentor.py,sha256=txKj7tZaXY0gznc8QVOyMI-LA5r7tfSPJkleZPI1fWQ,5051
+monocle_apptrace/utils.py,sha256=l3FAVF0rFbsph1LFdTMcs7K5ASiaovRQBmBeFYEHZmU,3174
+monocle_apptrace/wrap_common.py,sha256=rhiY2PE2WoLYofbby3LioTSjFG8YrMlhUnc82yXRkFk,12612
+monocle_apptrace/wrapper.py,sha256=cNUdfciAXNYAhvtOA2O4ONRvuT2bbHb4ax_7pALijEI,734
+monocle_apptrace/exporters/file_exporter.py,sha256=gN9pJ_X5pcstVVsyivgHsjWhr443eRa6Y6Hx1rGLQAM,2280
+monocle_apptrace/haystack/__init__.py,sha256=95LGUcUZbOcX5h-NwNrquKycp-qhuwCmcMfWAwxGylQ,321
+monocle_apptrace/haystack/wrap_node.py,sha256=IK07Wn3Lk1Os9URsyrmB1HXOH2FNdzK9fNLlR8TZdYc,908
+monocle_apptrace/haystack/wrap_openai.py,sha256=Yp916DhOl0WI6virRi3L43snfsQm7PhI28wlDsg19v8,1536
+monocle_apptrace/haystack/wrap_pipeline.py,sha256=1bufscslUpjbSw_kVl24rngTMsiGV33oCKbTxwtWM6Q,2173
+monocle_apptrace/langchain/__init__.py,sha256=3ABxFk92mmRj67Y3z70leZ4j1ig9Z6OU--rtxzfNIIM,271
+monocle_apptrace/llamaindex/__init__.py,sha256=lr-rdprhXJdSt-Fp1LghW-hMxWgDN6lPFTQgyqnb7N0,573
+monocle_apptrace/metamodel/README.md,sha256=KYuuYqgA9PNbOjG0zYj2nAdvNEpyNN_Bk9M2tNdnZ_s,4598
+monocle_apptrace/metamodel/entities/README.md,sha256=ZE8PYne9F8xN4uu0CB1BOS8iM5QdKdpQjHuqCaw7Vkg,1553
+monocle_apptrace/metamodel/entities/entity_types.json,sha256=-J1ZbzrZny1c9HSQKwRZu2Un3c0JjX9FvsfHwlZvaaw,5435
+monocle_apptrace/metamodel/entities/entity_types.py,sha256=4CzobOm692tou1Tsv8YX_yrOhhnwMBF8hBAt1Czn_8Q,1076
+monocle_apptrace/metamodel/maps/haystack_methods.json,sha256=JmngkaKICAzOyrWNTWEOLYFrp99l5wcERYKE_SQRNxE,698
+monocle_apptrace/metamodel/maps/lang_chain_methods.json,sha256=HaOhhxb3PkI7tXPxXhWR4cnWrnEHU--k5pOY9RS0Uew,3119
+monocle_apptrace/metamodel/maps/llama_index_methods.json,sha256=qpODnBHkaDjPBYZNd7clwmp_2subTu-fmI08Ky5OWdg,2192
+monocle_apptrace/metamodel/spans/README.md,sha256=_uMkLLaWitQ_rPh7oQbW5Oe7uGSv2h_QA6YwxHRJi74,5433
+monocle_apptrace/metamodel/spans/span_example.json,sha256=R4YVyz3rkhVc_FxpeBkY9JfO0GwluFa2A2wn4LkOPbo,4402
+monocle_apptrace/metamodel/spans/span_format.json,sha256=GhfioGgMhG7St0DeYA1fgNtMkbr9wiQ1L2hovekRQ24,1512
+monocle_apptrace-0.1.1.dist-info/METADATA,sha256=2Oz22Sjk1qarR4h_RctVoYnQWq0LSklrXu05_GFJjjE,5215
+monocle_apptrace-0.1.1.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+monocle_apptrace-0.1.1.dist-info/licenses/LICENSE,sha256=ay9trLiP5I7ZsFXo6AqtkLYdRqe5S9r-DrPOvsNlZrg,9136
+monocle_apptrace-0.1.1.dist-info/licenses/NOTICE,sha256=9jn4xtwM_uUetJMx5WqGnhrR7MIhpoRlpokjSTlyt8c,112
+monocle_apptrace-0.1.1.dist-info/RECORD,,

monocle_apptrace-0.1.0.dist-info/METADATA

@@ -1,77 +0,0 @@
-Metadata-Version: 2.3
-Name: monocle_apptrace
-Version: 0.1.0
-Summary: package with monocle genAI tracing
-Project-URL: Homepage, https://github.com/monocle2ai/monocle
-Project-URL: Issues, https://github.com/monocle2ai/monocle/issues
-License-File: LICENSE
-License-File: NOTICE
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.8
-Requires-Dist: opentelemetry-api>=1.21.0
-Requires-Dist: opentelemetry-instrumentation
-Requires-Dist: opentelemetry-sdk>=1.21.0
-Requires-Dist: requests
-Requires-Dist: wrapt>=1.14.0
-Provides-Extra: dev
-Requires-Dist: datasets==2.20.0; extra == 'dev'
-Requires-Dist: faiss-cpu==1.8.0; extra == 'dev'
-Requires-Dist: instructorembedding==1.0.1; extra == 'dev'
-Requires-Dist: langchain-chroma==0.1.1; extra == 'dev'
-Requires-Dist: langchain-community==0.2.5; extra == 'dev'
-Requires-Dist: langchain-openai==0.1.8; extra == 'dev'
-Requires-Dist: langchain==0.2.5; extra == 'dev'
-Requires-Dist: llama-index-embeddings-huggingface==0.2.0; extra == 'dev'
-Requires-Dist: llama-index-vector-stores-chroma==0.1.9; extra == 'dev'
-Requires-Dist: llama-index==0.10.30; extra == 'dev'
-Requires-Dist: numpy==1.26.4; extra == 'dev'
-Requires-Dist: parameterized==0.9.0; extra == 'dev'
-Requires-Dist: pytest==8.0.0; extra == 'dev'
-Requires-Dist: sentence-transformers==2.6.1; extra == 'dev'
-Requires-Dist: types-requests==2.31.0.20240106; extra == 'dev'
-Description-Content-Type: text/markdown
-
-# monocle genAI observability
-### Background
-Generative AI (GenAI) is the type of AI used to create content such as conversations, images, or video based on prior learning from existing content. GenAI relies on foundational models, which are exceptionally large ML models trained on vast amounts of generalized and unlabeled data to perform variety of general tasks such as understanding language and generating new text, audio or images from user provided prompts in a human language. Foundational models (FM) work by using learned patterns and relationships from the training data to predict the next item in a sequence given a prompt. It is cheaper and faster for data scientists to use foundational models as starting points rather than building models from scratch to build ML apps.  
-Large Language Models (LLMs) are a class of foundational models trained on text data used to perform a variety of tasks such as understanding language, reasoning over text, and generating new text based on user prompts in a human language. Examples of LLMs include ChatGPT, Llama, and Claude. 
-LLM-based AI apps leverage understanding language, reasoning & text generation to augment or automate complex tasks that typically require human intervention such as summarizing legal documents, triaging customer support tickets, or more.  
-Typically, AI developers build LLM-based AI apps that automate complex workflows by combining multiple LLMs and components such as prompts, vectors, or agents that each solve a discrete task that are connected by chains or pipelines in different ways using LLM (Large Language Model) orchestration frameworks.  
-When deployed to production, different parts of multi-component distributed LLM-based AI apps run on a combination of different kinds of AI infrastructure such as LLM-as-a-Service, GPU (graphics processing units) clouds, managed services from cloud, or custom-engineered AI stack. Typically, these systems are managed in production by IT DevOps engineers.  
-AI developers code, monitor, debug and optimize the resources in an LLM-based AI application. IT DevOps engineers monitor, troubleshoot, and optimize the services in the AI infra that the LLM-based AI application runs on. 
-
-## Introducing “Monocle – An eye for A.I.”
-The goal of project Monocle is to help GenAI developer to trace their applications. A typical GenAI application comprises of several technology components like application code/workflow, models, inferences services, vector databases etc. Understanding the dependencies and tracking application quickly becomes a difficult task. Monocle can be integrated into application code with very little to no code changes. Monocle supports tracing all GenAI technology components, application frameworks, LLM hosting services. We do all the hard work of finding what needs to be instrumented and how to instrument it. This enables the enlightened applications to generate detailed traces without any additional efforts from the developers.
-The traces are compatible with OpenTelemetry format. They are further enriched to contain lot more attribute relevant to GenAI applications like prompts. The project will have out of box support to store the traces locally and a extensibility for a third party store which can be implemented by end user or a supplied by third party vendors.    
-
-## Monocle integration
-### genAI Appliation frameworks
-- Langchain
-- LlamaIndex
-- Haystack
-### LLMs
-- OpenAI
-- Azure OpenAI
-- NVIDIA Triton
-
-## Getting started
-### Try Monocle with your python genAI application
-- Get latest Monocle python brary 
-```
-    pip install monocle_apptrace
-```
-- Enable Monocle tracing in your app by adding following
-```
-    setup_monocle_telemetry(workflow_name="your-app-name")
-```
-Please refer to [Monocle user guide](Monocle_User_Guide.md) for more details
-
-## Get involved
-### Provide feedback
-- Submit issues and enhancements requests via Github issues
-
-### Contribute
-- Monocle is community based open source project. We welcome your contributions. Please refer to the CONTRIBUTING and CODE_OF_CONDUCT for guidelines. The [contributor's guide](CONTRIBUTING.md) provides technical details of the project.
-

monocle_apptrace-0.1.0.dist-info/RECORD

@@ -1,22 +0,0 @@
-monocle_apptrace/README.md,sha256=OVJgf1_HAm5L2-FSDZ-3AYfBjSxiT4fhE_CgKVaDVuQ,3104
-monocle_apptrace/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-monocle_apptrace/constants.py,sha256=wjObbmMTFL201x-bf3EOXevYygwkFH_1ng5dDrpE3z0,810
-monocle_apptrace/instrumentor.py,sha256=IDCuqzvTLzYKBzHGX3q1gbiboq07LMkdOA8DhOUTEEU,5051
-monocle_apptrace/utils.py,sha256=VMiWscPCNjp29IQE3ahprXjkfiMw160DbCo8WrjQCXk,2658
-monocle_apptrace/wrap_common.py,sha256=zbYlhL7V655exfdE0h_aT6-THmmHL1ltzsm4cBZ4jq8,10875
-monocle_apptrace/wrapper.py,sha256=cNUdfciAXNYAhvtOA2O4ONRvuT2bbHb4ax_7pALijEI,734
-monocle_apptrace/exporters/file_exporter.py,sha256=gN9pJ_X5pcstVVsyivgHsjWhr443eRa6Y6Hx1rGLQAM,2280
-monocle_apptrace/haystack/__init__.py,sha256=zcluKUIu1M9g_B3s_ZfzRS_vr7yMz5gj-6rqQ7bJ5B0,318
-monocle_apptrace/haystack/wrap_node.py,sha256=IK07Wn3Lk1Os9URsyrmB1HXOH2FNdzK9fNLlR8TZdYc,908
-monocle_apptrace/haystack/wrap_openai.py,sha256=Yp916DhOl0WI6virRi3L43snfsQm7PhI28wlDsg19v8,1536
-monocle_apptrace/haystack/wrap_pipeline.py,sha256=xRYMRzxvFPdcJ64E0bbMdMuWO_p3V1T7eIvb3-Um5DE,1661
-monocle_apptrace/langchain/__init__.py,sha256=HhvRJ_rl9cX4M8ckiOkJC7QHbklrttaY9RvDC51m1l4,268
-monocle_apptrace/llamaindex/__init__.py,sha256=3zmSNoVDjB-hh_M4eUr-hUP0bup7HKmWFVv_3xPAwsA,570
-monocle_apptrace/wrapper_config/haystack_methods.json,sha256=JmngkaKICAzOyrWNTWEOLYFrp99l5wcERYKE_SQRNxE,698
-monocle_apptrace/wrapper_config/lang_chain_methods.json,sha256=HaOhhxb3PkI7tXPxXhWR4cnWrnEHU--k5pOY9RS0Uew,3119
-monocle_apptrace/wrapper_config/llama_index_methods.json,sha256=qpODnBHkaDjPBYZNd7clwmp_2subTu-fmI08Ky5OWdg,2192
-monocle_apptrace-0.1.0.dist-info/METADATA,sha256=sQfm_x1NFthDhfMKX_ZDE0E5bDLSxUOtV1v6yXt0Wpc,5699
-monocle_apptrace-0.1.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-monocle_apptrace-0.1.0.dist-info/licenses/LICENSE,sha256=ay9trLiP5I7ZsFXo6AqtkLYdRqe5S9r-DrPOvsNlZrg,9136
-monocle_apptrace-0.1.0.dist-info/licenses/NOTICE,sha256=9jn4xtwM_uUetJMx5WqGnhrR7MIhpoRlpokjSTlyt8c,112
-monocle_apptrace-0.1.0.dist-info/RECORD,,