monocle-apptrace 0.0.1__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,
@@ -62,16 +84,18 @@ setup_monocle_telemetry(
         wrapper_methods=[
             WrapperMethod(
                 package="langchain.schema.runnable",
-                object="RunnableParallel",
+                object_name="RunnableParallel",
                 method="invoke",
                 span_name="langchain.workflow",
                 wrapper=task_wrapper),
             WrapperMethod(
                 package="langchain.schema.runnable",
-                object="RunnableParallel",
+                object_name="RunnableParallel",
                 method="ainvoke",
                 span_name="langchain.workflow",
                 wrapper=atask_wrapper)
         ])
 
-```
+# Trace is generated when the invoke() method is called in langchain.schema.runnable package
+
+```

monocle_apptrace/__init__.py

@@ -1,2 +0,0 @@
-
-

monocle_apptrace/constants.py

@@ -0,0 +1,22 @@
+# Azure environment constants
+AZURE_ML_ENDPOINT_ENV_NAME = "AZUREML_ENTRY_SCRIPT"
+AZURE_FUNCTION_WORKER_ENV_NAME = "FUNCTIONS_WORKER_RUNTIME"
+AZURE_APP_SERVICE_ENV_NAME = "WEBSITE_SITE_NAME"
+AWS_LAMBDA_ENV_NAME = "AWS_LAMBDA_RUNTIME_API"
+
+# Azure naming reference can be found here
+# https://learn.microsoft.com/en-us/azure/cloud-adoption-framework/ready/azure-best-practices/resource-abbreviations
+AZURE_FUNCTION_NAME = "azure.func"
+AZURE_APP_SERVICE_NAME = "azure.asp"
+AZURE_ML_SERVICE_NAME = "azure.mlw"
+AWS_LAMBDA_SERVICE_NAME = "aws.lambda"
+
+azure_service_map = {
+    AZURE_ML_ENDPOINT_ENV_NAME: AZURE_ML_SERVICE_NAME,
+    AZURE_APP_SERVICE_ENV_NAME: AZURE_APP_SERVICE_NAME,
+    AZURE_FUNCTION_WORKER_ENV_NAME: AZURE_FUNCTION_NAME
+}
+
+aws_service_map = {
+    AWS_LAMBDA_ENV_NAME: AWS_LAMBDA_SERVICE_NAME
+}

monocle_apptrace/exporters/file_exporter.py

@@ -0,0 +1,63 @@
+#pylint: disable=consider-using-with
+
+from os import linesep, path
+from io import TextIOWrapper
+from datetime import datetime
+from typing import Optional, Callable, Sequence
+from opentelemetry.sdk.trace import ReadableSpan
+from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
+from opentelemetry.sdk.resources import SERVICE_NAME
+
+DEFAULT_FILE_PREFIX:str = "monocle_trace_"
+DEFAULT_TIME_FORMAT:str = "%Y-%m-%d_%H.%M.%S"
+
+class FileSpanExporter(SpanExporter):
+    current_trace_id: int = None
+    current_file_path: str = None
+
+    def __init__(
+        self,
+        service_name: Optional[str] = None,
+        out_path:str = ".",
+        file_prefix = DEFAULT_FILE_PREFIX,
+        time_format = DEFAULT_TIME_FORMAT,
+        formatter: Callable[
+            [ReadableSpan], str
+        ] = lambda span: span.to_json()
+        + linesep,
+    ):
+        self.out_handle:TextIOWrapper = None
+        self.formatter = formatter
+        self.service_name = service_name
+        self.output_path = out_path
+        self.file_prefix = file_prefix
+        self.time_format = time_format
+
+    def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
+        for span in spans:
+            if span.context.trace_id != self.current_trace_id:
+                self.rotate_file(span.resource.attributes[SERVICE_NAME],
+                                span.context.trace_id)
+            self.out_handle.write(self.formatter(span))
+        self.out_handle.flush()
+        return SpanExportResult.SUCCESS
+
+    def rotate_file(self, trace_name:str, trace_id:int) -> None:
+        self.reset_handle()
+        self.current_file_path = path.join(self.output_path,
+                        self.file_prefix + trace_name + "_" + hex(trace_id) + "_"
+                        + datetime.now().strftime(self.time_format) + ".json")
+        self.out_handle = open(self.current_file_path, "w", encoding='UTF-8')
+        self.current_trace_id = trace_id
+
+    def force_flush(self, timeout_millis: int = 30000) -> bool:
+        self.out_handle.flush()
+        return True
+
+    def reset_handle(self) -> None:
+        if self.out_handle is not None:
+            self.out_handle.close()
+            self.out_handle = None
+
+    def shutdown(self) -> None:
+        self.reset_handle()

monocle_apptrace/haystack/__init__.py

@@ -1,28 +1,9 @@
 
-
+import os
 import logging
-from monocle_apptrace.haystack.wrap_openai import wrap_openai
-from monocle_apptrace.haystack.wrap_pipeline import wrap as wrap_pipeline
+from monocle_apptrace.utils import load_wrapper_from_config
 
 logger = logging.getLogger(__name__)
-
-HAYSTACK_METHODS = [
-    {
-        "package": "haystack.components.generators.openai",
-        "object": "OpenAIGenerator",
-        "method": "run",
-        "wrapper": wrap_openai,
-    },
-    {
-        "package": "haystack.components.generators.chat.openai",
-        "object": "OpenAIChatGenerator",
-        "method": "run",
-        "wrapper": wrap_openai,
-    },
-    {
-        "package": "haystack.core.pipeline.pipeline",
-        "object": "Pipeline",
-        "method": "run",
-        "wrapper": wrap_pipeline,
-    },
-]
+parent_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+HAYSTACK_METHODS = load_wrapper_from_config(
+    os.path.join(parent_dir, 'metamodel', 'maps', 'haystack_methods.json'))

monocle_apptrace/haystack/wrap_node.py

@@ -21,7 +21,7 @@ def wrap(tracer, to_wrap, wrapped, instance, args, kwargs):
         workflow_name = span.resource.attributes.get("service.name")
         span.set_attribute("workflow_name",workflow_name)
         span.set_attribute("workflow_type", WORKFLOW_TYPE_MAP["haystack"])
-        
+
         response = wrapped(*args, **kwargs)
 
     return response

monocle_apptrace/haystack/wrap_openai.py

@@ -1,5 +1,3 @@
-
-
 import logging
 from opentelemetry import context as context_api
 from opentelemetry.instrumentation.utils import _SUPPRESS_INSTRUMENTATION_KEY
@@ -17,9 +15,7 @@ def _set_input_attributes(span, kwargs, instance, args):
 
     if 'model' in instance.__dict__:
         model_name = instance.__dict__.get("model")
-        set_span_attribute(span, "openai_model_name", model_name)
-
-    return
+        set_span_attribute(span, "model_name", model_name)
 
 @dont_throw
 def _set_response_attributes(span, response):
@@ -39,14 +35,10 @@ def wrap_openai(tracer, to_wrap, wrapped, instance, args, kwargs):
     with tracer.start_as_current_span("haystack.openai") as span:
         if span.is_recording():
             _set_input_attributes(span, kwargs, instance, args)
-
-
-        
         response = wrapped(*args, **kwargs)
 
         if response:
             if span.is_recording():
                 _set_response_attributes(span, response)
-                
 
         return response

monocle_apptrace/haystack/wrap_pipeline.py

@@ -1,5 +1,3 @@
-
-
 import logging
 from opentelemetry import context as context_api
 from opentelemetry.context import attach, set_value
@@ -7,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__)
 
@@ -18,13 +17,15 @@ def wrap(tracer, to_wrap, wrapped, instance, args, kwargs):
     name = "haystack_pipeline"
     attach(set_value("workflow_name", name))
     inputs = set()
-    input = get_workflow_input(args, inputs)
+    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, input)
+        span.set_attribute(PROMPT_INPUT_KEY, workflow_input)
         workflow_name = span.resource.attributes.get("service.name")
         set_workflow_attributes(span, workflow_name)
-        
         response = wrapped(*args, **kwargs)
         set_workflow_output(span, response)
     return response
@@ -37,13 +38,25 @@ def get_workflow_input(args, inputs):
     for value in args[0].values():
         for text in value.values():
             inputs.add(text)
-    
-    input: str = ""
+
+    workflow_input: str = ""
 
     for input_str in inputs:
-        input = input + input_str
-    return input
+        workflow_input = workflow_input + input_str
+    return workflow_input
 
 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

@@ -10,25 +10,26 @@ from opentelemetry.sdk.trace import TracerProvider, Span
 from opentelemetry.sdk.trace.export import BatchSpanProcessor, SpanProcessor
 from opentelemetry.sdk.resources import SERVICE_NAME, Resource
 from opentelemetry import trace
-from monocle_apptrace.wrap_common import CONTEXT_PROPERTIES_KEY
-from monocle_apptrace.wrapper import INBUILT_METHODS_LIST, WrapperMethod
 from opentelemetry.context import get_value, attach, set_value
+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
 
 
 logger = logging.getLogger(__name__)
 
-_instruments = ("langchain >= 0.0.346",)
+_instruments = ()
 
 class MonocleInstrumentor(BaseInstrumentor):
-    
+
     workflow_name: str = ""
     user_wrapper_methods: list[WrapperMethod] = []
     instrumented_method_list: list[object] = []
-    
+
     def __init__(
             self,
-            user_wrapper_methods: list[WrapperMethod] = []) -> None:
-        self.user_wrapper_methods = user_wrapper_methods
+            user_wrapper_methods: list[WrapperMethod] = None) -> None:
+        self.user_wrapper_methods = user_wrapper_methods or []
         super().__init__()
 
     def instrumentation_dependencies(self) -> Collection[str]:
@@ -63,11 +64,11 @@ class MonocleInstrumentor(BaseInstrumentor):
                 self.instrumented_method_list.append(wrapped_method)
             except Exception as ex:
                 if wrapped_method in user_method_list:
-                    logger.error(f"""_instrument wrap Exception: {str(ex)} 
+                    logger.error(f"""_instrument wrap Exception: {str(ex)}
                                 for package: {wrap_package},
                                 object:{wrap_object},
                                 method:{wrap_method}""")
-            
+
 
     def _uninstrument(self, **kwargs):
         for wrapped_method in self.instrumented_method_list:
@@ -80,48 +81,44 @@ class MonocleInstrumentor(BaseInstrumentor):
                     wrap_method,
                 )
             except Exception as ex:
-                logger.error(f"""_instrument unwrap Exception: {str(ex)} 
+                logger.error(f"""_instrument unwrap Exception: {str(ex)}
                              for package: {wrap_package},
                              object:{wrap_object},
                              method:{wrap_method}""")
-           
 
 def setup_monocle_telemetry(
         workflow_name: str,
-        span_processors: List[SpanProcessor] = [],
-        wrapper_methods: List[WrapperMethod] = []):
+        span_processors: List[SpanProcessor] = None,
+        wrapper_methods: List[WrapperMethod] = None):
     resource = Resource(attributes={
         SERVICE_NAME: workflow_name
     })
-    traceProvider = TracerProvider(resource=resource)
-    tracerProviderDefault = trace.get_tracer_provider()
-    providerType = type(tracerProviderDefault).__name__
-    isProxyProvider = "Proxy" in providerType
+    span_processors = span_processors or [BatchSpanProcessor(FileSpanExporter())]
+    trace_provider = TracerProvider(resource=resource)
+    tracer_provider_default = trace.get_tracer_provider()
+    provider_type = type(tracer_provider_default).__name__
+    is_proxy_provider = "Proxy" in provider_type
     for processor in span_processors:
         processor.on_start = on_processor_start
-        if not isProxyProvider:
-            tracerProviderDefault.add_span_processor(processor)
+        if not is_proxy_provider:
+            tracer_provider_default.add_span_processor(processor)
         else :
-            traceProvider.add_span_processor(processor)
-    if isProxyProvider :
-        trace.set_tracer_provider(traceProvider)
-    instrumentor = MonocleInstrumentor(user_wrapper_methods=wrapper_methods)
-    instrumentor.app_name = workflow_name
+            trace_provider.add_span_processor(processor)
+    if is_proxy_provider :
+        trace.set_tracer_provider(trace_provider)
+    instrumentor = MonocleInstrumentor(user_wrapper_methods=wrapper_methods or [])
+    # instrumentor.app_name = workflow_name
     if not instrumentor.is_instrumented_by_opentelemetry:
         instrumentor.instrument()
 
 
 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

@@ -1,95 +1,6 @@
+import os
+from monocle_apptrace.utils import load_wrapper_from_config
 
-
-from monocle_apptrace.wrap_common import allm_wrapper, atask_wrapper, llm_wrapper, task_wrapper
-
-LANGCHAIN_METHODS = [
-    {
-        "package": "langchain.prompts.base",
-        "object": "BasePromptTemplate",
-        "method": "invoke",
-        "wrapper": task_wrapper,
-    },
-    {
-        "package": "langchain.prompts.base",
-        "object": "BasePromptTemplate",
-        "method": "ainvoke",
-        "wrapper": atask_wrapper,
-    },
-    {
-        "package": "langchain.chat_models.base",
-        "object": "BaseChatModel",
-        "method": "invoke",
-        "wrapper": llm_wrapper,
-    },
-    {
-        "package": "langchain.chat_models.base",
-        "object": "BaseChatModel",
-        "method": "ainvoke",
-        "wrapper": allm_wrapper,
-    },
-    {
-        "package": "langchain_core.language_models.llms",
-        "object": "LLM",
-        "method": "_generate",
-        "wrapper": llm_wrapper,
-    },
-    {
-        "package": "langchain_core.language_models.llms",
-        "object": "LLM",
-        "method": "_agenerate",
-        "wrapper": llm_wrapper,
-    },
-    {
-        "package": "langchain_core.retrievers",
-        "object": "BaseRetriever",
-        "method": "invoke",
-        "wrapper": task_wrapper,
-    },
-    {
-        "package": "langchain_core.retrievers",
-        "object": "BaseRetriever",
-        "method": "ainvoke",
-        "wrapper": atask_wrapper,
-    },
-    {
-        "package": "langchain.schema",
-        "object": "BaseOutputParser",
-        "method": "invoke",
-        "wrapper": task_wrapper,
-    },
-    {
-        "package": "langchain.schema",
-        "object": "BaseOutputParser",
-        "method": "ainvoke",
-        "wrapper": atask_wrapper,
-    },
-    {
-        "package": "langchain.schema.runnable",
-        "object": "RunnableSequence",
-        "method": "invoke",
-        "span_name": "langchain.workflow",
-        "wrapper": task_wrapper,
-    },
-    {
-        "package": "langchain.schema.runnable",
-        "object": "RunnableSequence",
-        "method": "ainvoke",
-        "span_name": "langchain.workflow",
-        "wrapper": atask_wrapper,
-    },
-    {
-        "package": "langchain.schema.runnable",
-        "object": "RunnableParallel",
-        "method": "invoke",
-        "span_name": "langchain.workflow",
-        "wrapper": task_wrapper,
-    },
-    {
-        "package": "langchain.schema.runnable",
-        "object": "RunnableParallel",
-        "method": "ainvoke",
-        "span_name": "langchain.workflow",
-        "wrapper": atask_wrapper,
-    },
-    
-]
+parent_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+LANGCHAIN_METHODS = load_wrapper_from_config(
+    os.path.join(parent_dir, 'metamodel', 'maps', 'lang_chain_methods.json'))

monocle_apptrace/llamaindex/__init__.py

@@ -1,71 +1,15 @@
 
-
-from monocle_apptrace.wrap_common import allm_wrapper, atask_wrapper, llm_wrapper, task_wrapper
+#pylint: disable=protected-access
+import os
+from monocle_apptrace.utils import load_wrapper_from_config
 
 def get_llm_span_name_for_openai(instance):
-    if (hasattr(instance, "_is_azure_client") 
+    if (hasattr(instance, "_is_azure_client")
         and callable(getattr(instance, "_is_azure_client"))
         and instance._is_azure_client()):
         return "llamaindex.azure_openai"
     return "llamaindex.openai"
 
-LLAMAINDEX_METHODS = [
-    {
-        "package": "llama_index.core.indices.base_retriever",
-        "object": "BaseRetriever",
-        "method": "retrieve",
-        "span_name": "llamaindex.retrieve",
-        "wrapper": task_wrapper
-    },
-    {
-        "package": "llama_index.core.indices.base_retriever",
-        "object": "BaseRetriever",
-        "method": "aretrieve",
-        "span_name": "llamaindex.retrieve",
-        "wrapper": atask_wrapper
-    },
-    {
-        "package": "llama_index.core.base.base_query_engine",
-        "object": "BaseQueryEngine",
-        "method": "query",
-        "span_name": "llamaindex.query",
-        "wrapper": task_wrapper,
-    },
-    {
-        "package": "llama_index.core.base.base_query_engine",
-        "object": "BaseQueryEngine",
-        "method": "aquery",
-        "span_name": "llamaindex.query",
-        "wrapper": atask_wrapper,
-    },
-    {
-        "package": "llama_index.core.llms.custom",
-        "object": "CustomLLM",
-        "method": "chat",
-        "span_name": "llamaindex.llmchat",
-        "wrapper": task_wrapper,
-    },
-    {
-        "package": "llama_index.core.llms.custom",
-        "object": "CustomLLM",
-        "method": "achat",
-        "span_name": "llamaindex.llmchat",
-        "wrapper": atask_wrapper,
-    },
-    {
-        "package": "llama_index.llms.openai.base",
-        "object": "OpenAI",
-        "method": "chat",
-        "span_name": "llamaindex.openai",
-        "span_name_getter" : get_llm_span_name_for_openai,
-        "wrapper": llm_wrapper,
-    },
-     {
-        "package": "llama_index.llms.openai.base",
-        "object": "OpenAI",
-        "method": "achat",
-        "span_name": "llamaindex.openai",
-        "wrapper": allm_wrapper,
-    }
-]
-
+parent_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+LLAMAINDEX_METHODS = load_wrapper_from_config(
+    os.path.join(parent_dir, 'metamodel', 'maps', 'llama_index_methods.json'))