ibm-watsonx-orchestrate 1.12.0b0__py3-none-any.whl → 1.13.0b0__py3-none-any.whl

ibm_watsonx_orchestrate/flow_builder/flows/flow.py

@@ -21,17 +21,20 @@ from typing_extensions import Self
 from pydantic import BaseModel, Field, SerializeAsAny, create_model, TypeAdapter
 import yaml
 from ibm_watsonx_orchestrate.agent_builder.tools.python_tool import PythonTool
+from ibm_watsonx_orchestrate.agent_builder.models.types import ListVirtualModel
 from ibm_watsonx_orchestrate.client.tools.tool_client import ToolClient
 from ibm_watsonx_orchestrate.client.tools.tempus_client import TempusClient
 from ibm_watsonx_orchestrate.client.utils import instantiate_client
 from ..types import (
-    DocProcKVPSchema, Assignment, Conditions, EndNodeSpec, Expression, ForeachPolicy, ForeachSpec, LoopSpec, BranchNodeSpec, MatchPolicy, NodeIdCondition, PlainTextReadingOrder, PromptExample, PromptLLMParameters, PromptNodeSpec, TimerNodeSpec,
+    DocProcKVPSchema, Assignment, Conditions, EndNodeSpec, Expression, ForeachPolicy, ForeachSpec, LoopSpec, BranchNodeSpec, MatchPolicy,
+    NodeIdCondition, PlainTextReadingOrder, PromptExample, PromptLLMParameters, PromptNodeSpec, ScriptNodeSpec, TimerNodeSpec,
+    NodeErrorHandlerConfig, NodeIdCondition, PlainTextReadingOrder, PromptExample, PromptLLMParameters, PromptNodeSpec,
     StartNodeSpec, ToolSpec, JsonSchemaObject, ToolRequestBody, ToolResponseBody, UserFieldKind, UserFieldOption, UserFlowSpec, UserNodeSpec, WaitPolicy,
     DocProcSpec, TextExtractionResponse, DocProcInput, DecisionsNodeSpec, DecisionsRule, DocExtSpec, File, DocumentClassificationResponse, DocClassifierSpec, DocumentProcessingCommonInput
 )
 from .constants import CURRENT_USER, START, END, ANY_USER
 from ..node import (
-    EndNode, Node, PromptNode, StartNode, UserNode, AgentNode, DataMap, ToolNode, DocProcNode, DecisionsNode, DocExtNode, DocClassifierNode
+    EndNode, Node, PromptNode, ScriptNode, StartNode, UserNode, AgentNode, DataMap, ToolNode, DocProcNode, DecisionsNode, DocExtNode, DocClassifierNode
 )
 from ..types import (
     AgentNodeSpec, extract_node_spec, FlowContext, FlowEventType, FlowEvent, FlowSpec,
@@ -84,6 +87,21 @@ class Flow(Node):
         # get Tool Client
         self._tool_client = instantiate_client(ToolClient)
 
+        # set llm_model to use for the flow if any
+        llm_model = kwargs.get("llm_model")
+        if llm_model:
+            if isinstance(llm_model, ListVirtualModel):
+                self.metadata["llm_model"] = llm_model.name
+            elif isinstance(llm_model, str):
+                self.metadata["llm_model"] = llm_model
+            else:
+                raise AssertionError(f"flow llm_model should be either a str or ListVirtualModel")
+        
+        # set agent_conversation_memory_turns_limit for the flow if any
+        agent_conversation_memory_turns_limit = kwargs.get("agent_conversation_memory_turns_limit")
+        if agent_conversation_memory_turns_limit:
+            self.metadata["agent_conversation_memory_turns_limit"] = agent_conversation_memory_turns_limit
+
     def _find_topmost_flow(self) -> Self:
         if self.parent:
             return self.parent._find_topmost_flow()
@@ -253,7 +271,8 @@ class Flow(Node):
                 
     def _create_node_from_tool_fn(
         self,
-        tool: Callable
+        tool: Callable,
+        error_handler_config: Optional[NodeErrorHandlerConfig] = None
     ) -> ToolNode:
         if not isinstance(tool, Callable):
             raise ValueError("Only functions with @tool decorator can be added.")
@@ -276,7 +295,8 @@ class Flow(Node):
                                      input_schema = tool_spec.input_schema,
                                      output_schema = tool_spec.output_schema,
                                      output_schema_object = spec.output_schema_object,
-                                     tool = tool_spec.name)
+                                     tool = tool_spec.name,
+                                     error_handler_config = error_handler_config,)
 
         return ToolNode(spec=toolnode_spec)
 
@@ -286,14 +306,18 @@ class Flow(Node):
         name: str | None = None,
         display_name: str | None = None,
         description: str | None = None,
-
         input_schema: type[BaseModel] | None = None,
         output_schema: type[BaseModel] | None = None,
-        input_map: DataMap = None
+        input_map: DataMap = None,
+        error_handler_config: NodeErrorHandlerConfig | None = None
     ) -> ToolNode:
         '''create a tool node in the flow'''
         if tool is None:
             raise ValueError("tool must be provided")
+
+
+        if isinstance(error_handler_config, dict):
+            error_handler_config = NodeErrorHandlerConfig.model_validate(error_handler_config)    
         
         if isinstance(tool, str):        
             name = name if name is not None and name != "" else tool
@@ -322,14 +346,16 @@ class Flow(Node):
                                      input_schema= _get_tool_request_body(input_schema_obj),
                                      output_schema= _get_tool_response_body(output_schema_obj),
                                      output_schema_object = output_schema_obj,
-                                     tool = tool)
+                                     tool = tool,
+                                     error_handler_config = error_handler_config
+                                     )
 
             node = ToolNode(spec=toolnode_spec)
         elif isinstance(tool, PythonTool):
             if callable(tool):
                 tool_spec = getattr(tool, "__tool_spec__", None)
                 if tool_spec:
-                    node = self._create_node_from_tool_fn(tool)
+                    node = self._create_node_from_tool_fn(tool, error_handler_config = error_handler_config)
                 else:
                     raise ValueError("Only functions with @tool decorator can be added.")
         else:
@@ -341,6 +367,41 @@ class Flow(Node):
 
         node = self._add_node(node)
         return cast(ToolNode, node)
+    
+
+    def script(
+        self,
+        script: str | None = "",
+        name: str | None = None,
+        display_name: str | None = None,
+        description: str | None = None,
+        input_schema: type[BaseModel] | None = None,
+        output_schema: type[BaseModel] | None = None,
+        input_map: DataMap = None
+    ) -> ScriptNode:
+        '''create a script node in the flow'''    
+        name = name if name is not None and name != "" else ""
+
+        input_schema_obj = _get_json_schema_obj("input", input_schema)
+        output_schema_obj = _get_json_schema_obj("output", output_schema)
+
+        script_node_spec = ScriptNodeSpec(
+                                name = name,
+                                display_name = display_name,
+                                description = description,
+                                input_schema= _get_tool_request_body(input_schema_obj),
+                                output_schema= _get_tool_response_body(output_schema_obj),
+                                output_schema_object = output_schema_obj,
+                                fn = script)
+
+        node = ScriptNode(spec=script_node_spec)
+
+        # setup input and output map
+        if input_map:
+            node.input_map = self._get_data_map(input_map)
+
+        node = self._add_node(node)
+        return cast(ScriptNode, node)
  
 
     def _add_node(self, node: Node) -> Node:
@@ -407,7 +468,8 @@ class Flow(Node):
             description: str | None = None,
             input_schema: type[BaseModel]|None = None, 
             output_schema: type[BaseModel]|None=None,
-            input_map: DataMap = None) -> PromptNode:
+            input_map: DataMap = None,
+            error_handler_config: NodeErrorHandlerConfig | None = None,) -> PromptNode:
 
         if name is None:
             raise ValueError("name must be provided.")
@@ -426,6 +488,7 @@ class Flow(Node):
             prompt_examples=prompt_examples,
             llm=llm,
             llm_parameters=llm_parameters,
+            error_handler_config=error_handler_config,
             input_schema=_get_tool_request_body(input_schema_obj),
             output_schema=_get_tool_response_body(output_schema_obj),
             output_schema_object = output_schema_obj
@@ -519,7 +582,9 @@ class Flow(Node):
             fields: type[BaseModel]| None = None, 
             description: str | None = None,
             input_map: DataMap = None,
-            enable_hw: bool = False) -> tuple[DocExtNode, type[BaseModel]]:
+            enable_hw: bool = False,
+            min_confidence: float = 0, # Setting a small value because htil is not supported for pro code. 
+            review_fields: List[str] = []) -> tuple[DocExtNode, type[BaseModel]]:
         
         if name is None :
             raise ValueError("name must be provided.")
@@ -544,7 +609,9 @@ class Flow(Node):
             output_schema_object = output_schema_obj,
             config=doc_ext_config,
             version=version,
-            enable_hw=enable_hw
+            enable_hw=enable_hw,
+            min_confidence=min_confidence,
+            review_fields=review_fields
         )
         node = DocExtNode(spec=task_spec)
 
@@ -609,7 +676,8 @@ class Flow(Node):
             input_map: DataMap = None,
             document_structure: bool = False,
             kvp_schemas: list[DocProcKVPSchema] = None,
-            enable_hw: bool = False) -> DocProcNode:
+            enable_hw: bool = False,
+            kvp_model_name: str | None = None) -> DocProcNode:
 
         if name is None :
             raise ValueError("name must be provided.")
@@ -635,7 +703,8 @@ class Flow(Node):
             document_structure=document_structure,
             plain_text_reading_order=plain_text_reading_order,
             enable_hw=enable_hw,
-            kvp_schemas=kvp_schemas
+            kvp_schemas=kvp_schemas,
+            kvp_model_name=kvp_model_name
         )
 
         node = DocProcNode(spec=task_spec)
@@ -1201,7 +1270,7 @@ class CompiledFlow(BaseModel):
         dumped = self.flow.to_json()
         with open(file, 'w') as f:
             if file.endswith(".yaml") or file.endswith(".yml"):
-                yaml.dump(dumped, f)
+                yaml.dump(dumped, f, allow_unicode=True)
             elif file.endswith(".json"):
                 json.dump(dumped, f, indent=2)
             else:
@@ -1223,7 +1292,10 @@ class FlowFactory(BaseModel):
                     initiators: Sequence[str]|None=None,
                     input_schema: type[BaseModel]|None=None,
                     output_schema: type[BaseModel]|None=None,
-                    schedulable: bool=False) -> Flow:
+                    private_schema: type[BaseModel]|None=None,
+                    schedulable: bool=False,
+                    llm_model: str|ListVirtualModel|None=None,
+                    agent_conversation_memory_turns_limit: int|None = None) -> Flow:
         if isinstance(name, Callable):
             flow_spec = getattr(name, "__flow_spec__", None)
             if not flow_spec:
@@ -1233,6 +1305,7 @@ class FlowFactory(BaseModel):
         input_schema_obj = _get_json_schema_obj(parameter_name = "input", type_def = input_schema)
         # create input spec
         output_schema_obj = _get_json_schema_obj("output", output_schema)
+        private_schema_obj = _get_json_schema_obj("private", private_schema)
         if initiators is None:
             initiators = []
 
@@ -1244,11 +1317,12 @@ class FlowFactory(BaseModel):
             initiators=initiators,
             input_schema=_get_tool_request_body(input_schema_obj),
             output_schema=_get_tool_response_body(output_schema_obj),
+            private_schema = private_schema_obj,
             output_schema_object = output_schema_obj,
             schedulable=schedulable,
         )
 
-        return Flow(spec = flow_spec)
+        return Flow(spec = flow_spec, llm_model=llm_model, agent_conversation_memory_turns_limit=agent_conversation_memory_turns_limit)
 
 
 class FlowControl(Node):

ibm_watsonx_orchestrate/flow_builder/node.py

@@ -6,7 +6,7 @@ import yaml
 from pydantic import BaseModel, Field, SerializeAsAny, create_model
 from enum import Enum
 
-from .types import Assignment, DocExtConfigField, EndNodeSpec, NodeSpec, AgentNodeSpec, PromptNodeSpec, TimerNodeSpec, StartNodeSpec, ToolNodeSpec, UserFieldKind, UserFieldOption, UserNodeSpec, DocProcSpec, \
+from .types import Assignment, DocExtConfigField, EndNodeSpec, NodeSpec, AgentNodeSpec, PromptNodeSpec, ScriptNodeSpec, TimerNodeSpec, StartNodeSpec, ToolNodeSpec, UserFieldKind, UserFieldOption, UserNodeSpec, DocProcSpec, \
                     DocExtSpec, DocExtConfig, DocClassifierSpec, DecisionsNodeSpec, DocClassifierConfig
 
 from .data_map import DataMap
@@ -23,7 +23,7 @@ class Node(BaseModel):
                                       exclude_unset=True, exclude_none=True, by_alias=True)
         with open(file, 'w', encoding="utf-8") as f:
             if file.endswith('.yaml') or file.endswith('.yml'):
-                yaml.dump(dumped, f)
+                yaml.dump(dumped, f, allow_unicode=True)
             elif file.endswith('.json'):
                 json.dump(dumped, f, indent=2)
             else:
@@ -132,6 +132,18 @@ class ToolNode(Node):
 
     def get_spec(self) -> ToolNodeSpec:
         return cast(ToolNodeSpec, self.spec)
+    
+
+class ScriptNode(Node):
+    def __repr__(self):
+        return f"ScriptNode(name='{self.spec.name}', description='{self.spec.description}')"
+
+    def get_spec(self) -> ScriptNodeSpec:
+        return cast(ScriptNodeSpec, self.spec)
+    
+    def updateScript(self, script: str):
+        '''Update the script of a script node'''
+        self.spec.fn = script
 
 class UserNode(Node):
     def __repr__(self):

ibm_watsonx_orchestrate/flow_builder/types.py

@@ -271,6 +271,8 @@ class DocClassifierSpec(DocProcCommonNodeSpec):
 class DocExtSpec(DocProcCommonNodeSpec):
     version : str = Field(description="A version of the spec")
     config : DocExtConfig
+    min_confidence: float = Field(description="The minimal confidence acceptable for an extracted field value", default=0.0,le=1.0, ge=0.0 ,title="Minimum Confidence")
+    review_fields: List[str] = Field(description="The fields that require user to review", default=[])
 
     def __init__(self, **data):
         super().__init__(**data)
@@ -281,6 +283,8 @@ class DocExtSpec(DocProcCommonNodeSpec):
         model_spec["version"] = self.version
         model_spec["config"] = self.config.model_dump()
         model_spec["task"] = DocProcTask.custom_field_extraction
+        model_spec["min_confidence"] = self.min_confidence
+        model_spec["review_fields"] = self.review_fields
         return model_spec
     
 class DocProcField(BaseModel):
@@ -337,6 +341,11 @@ class DocProcSpec(DocProcCommonNodeSpec):
         title='KVP schemas',
         description="Optional list of key-value pair schemas to use for extraction.",
         default=None)
+    kvp_model_name: str | None = Field(
+        title='KVP Model Name',
+        description="The LLM model to be used for key-value pair extraction",
+        default=None
+    )
     plain_text_reading_order : PlainTextReadingOrder = Field(default=PlainTextReadingOrder.block_structure)
     document_structure: bool = Field(default=False,description="Requests the entire document structure computed by WDU to be returned")
     
@@ -352,6 +361,8 @@ class DocProcSpec(DocProcCommonNodeSpec):
             model_spec["plain_text_reading_order"] = self.plain_text_reading_order
         if self.kvp_schemas is not None:
             model_spec["kvp_schemas"] = self.kvp_schemas
+        if self.kvp_model_name is not None:
+            model_spec["kvp_model_name"] = self.kvp_model_name
         return model_spec
 
 class StartNodeSpec(NodeSpec):
@@ -363,8 +374,24 @@ class EndNodeSpec(NodeSpec):
     def __init__(self, **data):
         super().__init__(**data)
         self.kind = "end"
+
+class NodeErrorHandlerConfig(BaseModel):
+    error_message: Optional[str] = None
+    max_retries: Optional[int] = None
+    retry_interval: Optional[int] = None
+        
+    def to_json(self) -> dict[str, Any]:
+        model_spec = {}
+        if self.error_message:
+            model_spec["error_message"] = self.error_message
+        if self.max_retries:
+            model_spec["max_retries"] = self.max_retries
+        if self.retry_interval:
+            model_spec["retry_interval"] = self.retry_interval
+        return model_spec
 class ToolNodeSpec(NodeSpec):
     tool: Union[str, ToolSpec] = Field(default = None, description="the tool to use")
+    error_handler_config: Optional[NodeErrorHandlerConfig] = None
 
     def __init__(self, **data):
         super().__init__(**data)
@@ -372,12 +399,27 @@ class ToolNodeSpec(NodeSpec):
 
     def to_json(self) -> dict[str, Any]:
         model_spec = super().to_json()
+        if self.error_handler_config:
+            model_spec["error_handler_config"] = self.error_handler_config.to_json()  
         if self.tool:
             if isinstance(self.tool, ToolSpec):
                 model_spec["tool"] = self.tool.model_dump(exclude_defaults=True, exclude_none=True, exclude_unset=True)
             else:
                 model_spec["tool"] = self.tool
         return model_spec
+    
+class ScriptNodeSpec(NodeSpec):
+     fn: str = Field(default = None, description="the script to execute")
+
+     def __init__(self, **data):
+         super().__init__(**data)
+         self.kind = "script"
+
+     def to_json(self) -> dict[str, Any]:
+         model_spec = super().to_json()
+         if self.fn:
+             model_spec["fn"] = self.fn
+         return model_spec
 
 
 class UserFieldValue(BaseModel):
@@ -708,6 +750,7 @@ class PromptNodeSpec(NodeSpec):
     prompt_examples: Optional[list[PromptExample]]
     llm: Optional[str] 
     llm_parameters: Optional[PromptLLMParameters] 
+    error_handler_config: Optional[NodeErrorHandlerConfig] 
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
@@ -723,6 +766,8 @@ class PromptNodeSpec(NodeSpec):
             model_spec["llm"] = self.llm
         if self.llm_parameters:
             model_spec["llm_parameters"] = self.llm_parameters.to_json()
+        if self.error_handler_config:
+            model_spec["error_handler_config"] = self.error_handler_config.to_json()            
         if self.prompt_examples:
             model_spec["prompt_examples"] = []
             for example in self.prompt_examples:
@@ -860,6 +905,9 @@ class FlowSpec(NodeSpec):
     initiators: Sequence[str] = [ANY_USER]
     schedulable: bool = False
 
+    # flow can have private schema
+    private_schema: JsonSchemaObject | SchemaRef | None = None
+
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         self.kind = "flow"
@@ -868,6 +916,8 @@ class FlowSpec(NodeSpec):
         model_spec = super().to_json()
         if self.initiators:
             model_spec["initiators"] = self.initiators
+        if self.private_schema:
+             model_spec["private_schema"] = _to_json_from_json_schema(self.private_schema)
         
         model_spec["schedulable"] = self.schedulable
 
@@ -905,8 +955,7 @@ class UserFlowSpec(FlowSpec):
 class ForeachPolicy(Enum):
  
     SEQUENTIAL = 1
-    # support only SEQUENTIAL for now
-    # PARALLEL = 2
+    PARALLEL = 2
 
 class ForeachSpec(FlowSpec):
  
@@ -923,7 +972,7 @@ class ForeachSpec(FlowSpec):
         if isinstance(self.item_schema, JsonSchemaObject):
             my_dict["item_schema"] = _to_json_from_json_schema(self.item_schema)
         else:
-            my_dict["item_schema"] = self.item_schema.model_dump(exclude_defaults=True, exclude_none=True, exclude_unset=True)
+            my_dict["item_schema"] = self.item_schema.model_dump(exclude_defaults=True, exclude_none=True, exclude_unset=True, by_alias=True)
 
         my_dict["foreach_policy"] = self.foreach_policy.name
         return my_dict
@@ -1312,6 +1361,11 @@ class DocProcInput(DocumentProcessingCommonInput):
         title='KVP schemas',
         description="Optional list of key-value pair schemas to use for extraction.",
         default=None)
+    kvp_model_name: str | None = Field(
+        title='KVP Model Name',
+        description="The LLM model to be used for key-value pair extraction",
+        default=None
+    )
 
 class TextExtractionResponse(BaseModel):
     '''

ibm_watsonx_orchestrate/langflow/langflow_utils.py

@@ -0,0 +1,195 @@
+import logging
+import ast
+import sys
+from pathlib import Path
+import importlib.util
+
+from pydantic import BaseModel
+
+from .lfx_deps import LFX_DEPENDENCIES
+
+logger = logging.getLogger(__name__)
+
+class LangflowComponent(BaseModel):
+    id: str
+    name: str
+    credentials: dict
+    requirements: list[str] = []
+
+class LangflowModelSpec(BaseModel):
+    version: str
+    components: list[LangflowComponent]
+
+_MODULE_MAP = {
+    "mem0":"mem0ai",
+}
+
+import math
+from collections import Counter
+
+def _calculate_entropy(s):
+    """
+    Calculates the Shannon entropy of a string.
+
+    Parameters:
+        s (str): Input string.
+
+    Returns:
+        float: Shannon entropy value.
+    """
+    if not s:
+        return 0.0
+
+    freq = Counter(s)
+    length = len(s)
+
+    entropy = -sum((count / length) * math.log2(count / length) for count in freq.values())
+    return entropy
+
+def _mask_api_key(key):
+    """
+    Masks an API key by keeping the first 5 characters visible,
+    masking the rest with asterisks, and truncating the result to a maximum of 25 characters.
+
+    Parameters:
+        key (str): The API key string.
+
+    Returns:
+        str: Masked and truncated API key.
+    """
+    if not isinstance(key, str):
+        return key
+    
+    # if this is a potential real API key -- mask it
+    if _calculate_entropy(key) > 4.1:
+        visible_part = key[:5]
+        masked_part = '*' * (len(key) - 5)
+        masked_key = visible_part + masked_part
+
+        return masked_key[:25]
+    elif len(key) > 25:
+        # if the key is longer than 25 characters, truncates it anyway
+        return key[:22] + '...'
+    
+    return key
+
+def _extract_imports(source_code) -> list[str]:
+    tree = ast.parse(source_code)
+    imports = set()
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                # we only need the module name, not sub-module
+                imports.add(alias.name.split('.')[0])
+        elif isinstance(node, ast.ImportFrom):
+            if node.module:
+                # we only need the module name, not sub-module
+                imports.add(node.module.split('.')[0])
+    return sorted(imports)
+
+
+
+def _is_builtin_module(module_name: str) -> bool:
+    underscore_module_name = f"_{module_name}"
+
+    # Check against the list of standard modules 
+    if module_name in sys.stdlib_module_names:
+        return True
+    
+    if underscore_module_name in sys.stdlib_module_names:
+        return True
+
+    # Check against the list of built-in module names
+    if module_name in sys.builtin_module_names:
+        return True
+
+    if underscore_module_name in sys.builtin_module_names:
+        return True
+    
+    # Use importlib to find the module spec
+    spec = importlib.util.find_spec(module_name)
+    if spec is None:
+        return False  # Module not found
+
+    # Check if the loader is a BuiltinImporter
+    return isinstance(spec.loader, importlib.machinery.BuiltinImporter)
+
+
+def _find_missing_requirements(imported_modules, requirements_modules: list[str]) -> list[str]:
+    """
+    Compare imported modules with requirements.txt and return missing ones.
+
+    Parameters:
+        imported_modules (list): List of module names used in the code.
+        requirements_file_path (str): Path to the requirements.txt file.
+
+    Returns:
+        list: Modules that are imported but not listed in requirements.txt.
+    """
+    def normalize_module_name(name):
+        module_name = name.split('.')[0].lower()
+        # sometimes the module name in pipy is different than the real name
+        if module_name in _MODULE_MAP:
+            module_name = _MODULE_MAP[module_name]
+        return module_name
+
+    # Normalize imported module names
+    normalized_imports = [normalize_module_name(mod) for mod in imported_modules]
+
+    # filter out all built-ins
+    filtered_imports = [
+        module for module in normalized_imports
+        if _is_builtin_module(module) is False
+    ]
+
+    # Compare and find missing modules
+    missing_modules = [
+        module for module in filtered_imports
+        if module not in requirements_modules
+    ]
+
+    return missing_modules
+
+
+
+def parse_langflow_model(model) -> LangflowModelSpec:
+    """
+    Extracts component details and Langflow version from a Langflow JSON object.
+
+    Parameters:
+        model (dict): The Langflow JSON object.
+
+    Returns:
+        LangflowModelSpec: A LangflowModelSpec object containing the extracted version and component information.
+    """
+    version = model.get("last_tested_version", "Unknown")
+    components = []
+    data = model.get('data', {} )
+
+    # get the list of available modules
+    requirements_modules = LFX_DEPENDENCIES
+
+    for node in data.get("nodes", []):
+        node_data = node.get("data", {})
+        node_info = node_data.get("node", {})
+        template = node_info.get("template", {})
+        code = template.get("code")
+        credentials = {}
+
+        missing_imports = []
+        for field_name, field_info in template.items():
+            if isinstance(field_info, dict) and field_info.get("password", False) == True:
+                credentials[field_name] = _mask_api_key(field_info.get("value"))
+
+        if code and code.get("value") != None:
+            imports = _extract_imports(code.get("value"))
+            if len(imports) > 0:
+                missing_imports = _find_missing_requirements(imports, requirements_modules)
+
+        component_info = LangflowComponent(name=node_info.get("display_name", "Unknown"), id=node_data.get("id", "Unknown"), 
+                                           credentials=credentials, requirements=missing_imports)
+
+        components.append(component_info)
+
+    return LangflowModelSpec(version=version, components=components)
+