sunholo 0.64.5__tar.gz → 0.64.8__tar.gz

{sunholo-0.64.5 → sunholo-0.64.8}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: sunholo
-Version: 0.64.5
+Version: 0.64.8
 Summary: Large Language Model DevOps - a package to help deploy LLMs to the Cloud.
 Home-page: https://github.com/sunholo-data/sunholo-py
-Download-URL: https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.64.5.tar.gz
+Download-URL: https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.64.8.tar.gz
 Author: Holosun ApS
 Author-email: multivac@sunholo.com
 License: Apache License, Version 2.0

{sunholo-0.64.5 → sunholo-0.64.8}/setup.py

@@ -1,7 +1,7 @@
 from setuptools import setup, find_packages
 
 # Define your base version
-version = '0.64.5'
+version = '0.64.8'
 
 setup(
     name='sunholo',

{sunholo-0.64.5 → sunholo-0.64.8}/sunholo/agents/__init__.py

@@ -4,3 +4,4 @@ from .pubsub import process_pubsub
 from .special_commands import handle_special_commands, app_to_store, handle_files
 from .flask import register_qna_routes, create_app
 from .fastapi import register_qna_fastapi_routes, create_fastapi_app
+from .swagger import config_to_swagger

{sunholo-0.64.5 → sunholo-0.64.8}/sunholo/agents/flask/qna_routes.py

@@ -26,7 +26,7 @@ from ...logging import log
 from ...utils.config import load_config
 from ...utils.version import sunholo_version
 import os
-from ...gcs.add_file import add_file_to_gcs
+from ...gcs.add_file import add_file_to_gcs, handle_base64_image
 
 
 try:
@@ -41,7 +41,32 @@ except ImportError:
 
 
 def register_qna_routes(app, stream_interpreter, vac_interpreter):
+    """
+    Register Q&A routes for a Flask application.
 
+    This function sets up multiple routes for handling Q&A operations,
+    including streaming responses and processing static responses.
+
+    Args:
+        app (Flask): The Flask application instance.
+        stream_interpreter (function): Function to handle streaming Q&A responses.
+        vac_interpreter (function): Function to handle static Q&A responses.
+
+    Returns:
+        None
+
+    Example:
+        from flask import Flask
+        app = Flask(__name__)
+
+        def dummy_stream_interpreter(...):
+            ...
+
+        def dummy_vac_interpreter(...):
+            ...
+
+        register_qna_routes(app, dummy_stream_interpreter, dummy_vac_interpreter)
+    """
     @app.route("/")
     def home():
         return jsonify("OK")
@@ -52,6 +77,21 @@ def register_qna_routes(app, stream_interpreter, vac_interpreter):
 
     @app.route('/vac/streaming/<vector_name>', methods=['POST'])
     def stream_qa(vector_name):
+        """
+        Handle streaming Q&A responses.
+
+        This function sets up a route to handle streaming Q&A responses based on
+        the provided vector name.
+
+        Args:
+            vector_name (str): The name of the vector for the request.
+
+        Returns:
+            Response: A Flask response object streaming the Q&A response content.
+
+        Example:
+            response = stream_qa("example_vector")
+        """
         observed_stream_interpreter = observe()(stream_interpreter)
         prep = prep_vac(request, vector_name)
         log.debug(f"Processing prep: {prep}")
@@ -117,6 +157,21 @@ def register_qna_routes(app, stream_interpreter, vac_interpreter):
 
     @app.route('/vac/<vector_name>', methods=['POST'])
     def process_qna(vector_name):
+        """
+        Handle static Q&A responses.
+
+        This function sets up a route to handle static Q&A responses based on
+        the provided vector name.
+
+        Args:
+            vector_name (str): The name of the vector for the request.
+
+        Returns:
+            Response: A Flask response object with the Q&A response content.
+
+        Example:
+            response = process_qna("example_vector")
+        """
         observed_vac_interpreter = observe()(vac_interpreter)
         prep = prep_vac(request, vector_name)
         log.debug(f"Processing prep: {prep}")
@@ -167,6 +222,21 @@ def register_qna_routes(app, stream_interpreter, vac_interpreter):
     @app.route('/openai/v1/chat/completions', methods=['POST'])
     @app.route('/openai/v1/chat/completions/<vector_name>', methods=['POST'])
     def openai_compatible_endpoint(vector_name=None):
+        """
+        Handle OpenAI-compatible chat completions.
+
+        This function sets up routes to handle OpenAI-compatible chat completion requests,
+        both with and without a specified vector name.
+
+        Args:
+            vector_name (str, optional): The name of the vector for the request. Defaults to None.
+
+        Returns:
+            Response: A Flask response object with the chat completion content.
+
+        Example:
+            response = openai_compatible_endpoint("example_vector")
+        """
         data = request.get_json()
         log.info(f'openai_compatible_endpoint got data: {data} for vector: {vector_name}')
 
@@ -178,9 +248,29 @@ def register_qna_routes(app, stream_interpreter, vac_interpreter):
         if not messages:
             return jsonify({"error": "No messages provided"}), 400
 
-        user_message = next((msg['content'] for msg in reversed(messages) if msg['role'] == 'user'), None)
+        user_message = None
+        image_uri = None
+        mime_type = None
+
+        for msg in reversed(messages):
+            if msg['role'] == 'user':
+                if isinstance(msg['content'], list):
+                    for content_item in msg['content']:
+                        if content_item['type'] == 'text':
+                            user_message = content_item['text']
+                        elif content_item['type'] == 'image_url':
+                            base64_data = content_item['image_url']['url']
+                            image_uri, mime_type = handle_base64_image(base64_data, vector_name)
+                else:
+                    user_message = msg['content']
+                break
+
         if not user_message:
             return jsonify({"error": "No user message provided"}), 400
+        
+        if image_uri:
+            data["image_uri"] = image_uri
+            data["mime"] = mime_type
 
         all_input = {
             "user_input": user_message,
@@ -281,6 +371,22 @@ def register_qna_routes(app, stream_interpreter, vac_interpreter):
 
 
 def create_langfuse_trace(request, vector_name):
+    """
+    Create a Langfuse trace for tracking requests.
+
+    This function initializes a Langfuse trace object based on the request headers
+    and vector name.
+
+    Args:
+        request (Request): The Flask request object.
+        vector_name (str): The name of the vector for the request.
+
+    Returns:
+        Langfuse.Trace: The Langfuse trace object.
+
+    Example:
+        trace = create_langfuse_trace(request, "example_vector")
+    """
     try:
         from langfuse import Langfuse
         langfuse = Langfuse()
@@ -307,6 +413,22 @@ def create_langfuse_trace(request, vector_name):
     )
 
 def prep_vac(request, vector_name):
+    """
+    Prepare the input data for a VAC request.
+
+    This function processes the incoming request data, extracts relevant
+    information, and prepares the data for VAC processing.
+
+    Args:
+        request (Request): The Flask request object.
+        vector_name (str): The name of the vector for the request.
+
+    Returns:
+        dict: A dictionary containing prepared input data and metadata.
+
+    Example:
+        prep_data = prep_vac(request, "example_vector")
+    """
     #trace = create_langfuse_trace(request, vector_name)
     trace = None
     span = None
@@ -376,6 +498,25 @@ def prep_vac(request, vector_name):
 
 
 def handle_file_upload(file, vector_name):
+    """
+    Handle file upload and store the file in Google Cloud Storage.
+
+    This function saves the uploaded file locally, uploads it to Google Cloud Storage,
+    and then removes the local copy.
+
+    Args:
+        file (FileStorage): The uploaded file.
+        vector_name (str): The name of the vector for the request.
+
+    Returns:
+        tuple: A tuple containing the URI of the uploaded file and its MIME type.
+
+    Raises:
+        Exception: If the file upload fails.
+
+    Example:
+        uri, mime_type = handle_file_upload(file, "example_vector")
+    """
     try:
         file.save(file.filename)
         image_uri = add_file_to_gcs(file.filename, vector_name)

{sunholo-0.64.5 → sunholo-0.64.8}/sunholo/agents/route.py

@@ -14,7 +14,7 @@
 from ..logging import log
 from ..utils import load_config_key, load_config
 
-def route_qna(vector_name):
+def route_vac(vector_name):
 
     agent_url = load_config_key('agent_url', vector_name=vector_name, kind="vacConfig")
     if agent_url:
@@ -35,17 +35,22 @@ def route_qna(vector_name):
     log.info(f'agent_url: {agent_url}')
     return agent_url
 
-def route_endpoint(vector_name, override_endpoint=None):
+def route_endpoint(vector_name, method = 'post', override_endpoint=None):
 
     agent_type = load_config_key('agent_type', vector_name, kind="vacConfig")
     if not agent_type:
         agent_type = load_config_key('agent', vector_name, kind="vacConfig")
 
-    stem = route_qna(vector_name) if not override_endpoint else override_endpoint
+    stem = route_vac(vector_name) if not override_endpoint else override_endpoint
     
-    endpoints_config = load_config_key(agent_type, vector_name, kind="agentConfig")
+    agents_config = load_config_key(agent_type, vector_name, kind="agentConfig")
     
-    log.info(f"endpoints_config: {endpoints_config}")
+    log.info(f"endpoints_config: {agents_config}")
+    if method not in agents_config:
+        raise ValueError(f"Invalid method '{method}' for agent configuration.")
+
+    # 'post' or 'get'
+    endpoints_config = agents_config[method]
 
     # Replace placeholders in the config
     endpoints = {}

sunholo-0.64.8/sunholo/agents/swagger.py

@@ -0,0 +1,208 @@
+import yaml
+import copy
+
+from ..utils.config import load_all_configs
+from .route import route_vac
+from ..logging import log
+
+def config_to_swagger():
+    """
+    Load configuration files and generate a Swagger specification.
+
+    This function loads the 'vacConfig' and 'agentConfig' configuration files,
+    validates their presence, and then generates a Swagger specification
+    based on these configurations.
+
+    Returns:
+        str: The generated Swagger specification in YAML format.
+
+    Raises:
+        ValueError: If 'vacConfig' or 'agentConfig' is not loaded.
+
+    Example:
+    ```python
+        swagger_yaml = config_to_swagger()
+        print(swagger_yaml)
+    ```
+    """
+    configs = load_all_configs()
+
+    vac_config = configs.get('vacConfig')
+    agent_config = configs.get('agentConfig')
+
+    if not vac_config:
+        raise ValueError("Need valid 'vacConfig' loaded")
+    
+    if not agent_config:
+        raise ValueError("Need valid 'agentConfig' loaded")
+    
+    swag = generate_swagger(vac_config, agent_config)
+
+    return swag
+
+def generate_swagger(vac_config, agent_config):
+    """
+    Generate a Swagger specification based on the provided configurations.
+
+    This function creates a Swagger specification using the provided 'vacConfig'
+    and 'agentConfig'. It dynamically builds paths and responses based on the
+    configurations.
+
+    Args:
+        vac_config (dict): The VAC configuration.
+        agent_config (dict): The agent configuration.
+
+    Returns:
+        str: The generated Swagger specification in YAML format.
+
+    Example:
+    ```python
+        vac_config = {
+            'vac': {
+                'service1': {
+                    'llm': 'vertex',
+                    'model': 'gemini-1.5-flash-001',
+                    'agent': 'langserve'
+                },
+                'service2': {
+                    'llm': 'openai',
+                    'agent': 'crewai',
+                    'secrets': ['OPENAI_API_KEY']
+                }
+            }
+        }
+        
+        agent_config = {
+            'agents': {
+                'default': {
+                    'stream': "{stem}/vac/streaming/{vector_name}",
+                    'invoke': "{stem}/vac/{vector_name}",
+                    'post': {
+                        'stream': "{stem}/vac/streaming/{vector_name}",
+                        'invoke': "{stem}/vac/{vector_name}",
+                        'openai': "{stem}/openai/v1/chat/completions",
+                        'openai-vac': "{stem}/openai/v1/chat/completions/{vector_name}"
+                    },
+                    'get': {
+                        'home': "{stem}/",
+                        'health': "{stem}/health"
+                    },
+                    'response': {
+                        'invoke': {
+                            '200': {
+                                'description': 'Successful invocation response',
+                                'schema': {
+                                    'type': 'object',
+                                    'properties': {
+                                        'answer': {'type': 'string'},
+                                        'source_documents': {
+                                            'type': 'array',
+                                            'items': {
+                                                'type': 'object',
+                                                'properties': {
+                                                    'page_content': {'type': 'string'},
+                                                    'metadata': {'type': 'string'}
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        
+        swagger_yaml = generate_swagger(vac_config, agent_config)
+        print(swagger_yaml)
+        ```
+    """
+    swagger_template = {
+        'swagger': '2.0',
+        'info': {
+            'title': 'Multivac - Cloud Endpoints + Cloud Run',
+            'description': 'Multivac - Cloud Endpoints with a Cloud Run backend',
+            'version': '0.1.0'
+        },
+        'host': '${_ENDPOINTS_HOST}',
+        'schemes': ['https'],
+        'produces': ['application/json'],
+        'paths': {}
+    }
+    
+    vac_services = vac_config['vac']
+    
+    for vector_name, config in vac_services.items():
+        agent_type = config['agent']
+        agent_config_paths = agent_config['agents'].get(agent_type, {})
+        log.info(f'Configuring swagger for agent_type: {agent_type} for vector_name: {vector_name}')
+        try:
+            stem = route_vac(vector_name)
+        except ValueError:
+            stem = f"${{{agent_type.upper()}_BACKEND_URL}}"
+            log.warning(f"Failed to find URL stem for {vector_name}/{agent_type} - using {stem} instead")
+        
+        for method, endpoints in agent_config_paths.items():
+            if method not in ['get', 'post']:
+                log.warning(f"Skipping {endpoints}")
+                continue
+            for endpoint_key, endpoint_template in endpoints.items():
+                endpoint_path = endpoint_template.replace("{stem}", f"/{agent_type}").replace("{vector_name}", vector_name)
+                if endpoint_path not in swagger_template['paths']:
+                    swagger_template['paths'][endpoint_path] = {}
+                swagger_template['paths'][endpoint_path][method] = {
+                    'summary': f"{method.capitalize()} {vector_name}",
+                    'operationId': f"{method}_{agent_type}_{endpoint_key}",
+                    'x-google-backend': {
+                        'address': endpoint_template.replace("{stem}", stem).replace("{vector_name}", vector_name),
+                        'protocol': 'h2'
+                    },
+                    'responses': copy.deepcopy(agent_config_paths.get('response', {}).get(endpoint_key, {
+                        '200': {
+                            'description': 'Default - A successful response',
+                            'schema': {
+                                'type': 'string'
+                            }
+                        }
+                    }))
+                }
+    # Handle default agent configuration for agent types without specific entries
+    default_agent_config = agent_config['agents'].get('default', {})
+    
+    for vector_name, config in vac_services.items():
+        agent_type = config['agent']
+        if agent_type in agent_config['agents']:
+            continue
+        log.info(f'Applying default configuration for agent_type: {agent_type} for vector_name: {vector_name}')
+        try:
+            stem = route_vac(vector_name)
+        except ValueError:
+            stem = f"${{{agent_type.upper()}_BACKEND_URL}}"
+            log.warning(f"Failed to find URL stem for {vector_name}/{agent_type} - using {stem} instead")
+        
+        for method, endpoints in default_agent_config.items():
+            if method not in ['get', 'post']:
+                continue
+            for endpoint_key, endpoint_template in endpoints.items():
+                endpoint_path = endpoint_template.replace("{stem}", f"/{agent_type}").replace("{vector_name}", vector_name)
+                if endpoint_path not in swagger_template['paths']:
+                    swagger_template['paths'][endpoint_path] = {}
+                swagger_template['paths'][endpoint_path][method] = {
+                    'summary': f"{method.capitalize()} {agent_type}",
+                    'operationId': f"{method}_{agent_type}_{endpoint_key}",
+                    'x-google-backend': {
+                        'address': endpoint_template.replace("{stem}", stem).replace("{vector_name}", vector_name),
+                        'protocol': 'h2'
+                    },
+                    'responses': copy.deepcopy(default_agent_config.get('response', {}).get(endpoint_key, {
+                        '200': {
+                            'description': 'Default - A successful response',
+                            'schema': {
+                                'type': 'string'
+                            }
+                        }
+                    }))
+                }
+    
+    return yaml.dump(swagger_template, default_flow_style=False)

{sunholo-0.64.5 → sunholo-0.64.8}/sunholo/auth/run.py

@@ -5,14 +5,14 @@ from typing import Dict, Optional
 from ..utils.config import load_config_key, load_config
 from ..utils.gcp import is_running_on_cloudrun
 from ..logging import log
-from ..agents.route import route_qna
+from ..agents.route import route_vac
 
 def get_run_url(vector_name=None):
 
     if not vector_name:
         raise ValueError('Vector name was not specified')
     
-    cloud_urls = route_qna(vector_name)
+    cloud_urls = route_vac(vector_name)
     
     cloud_urls, _ = load_config('config/cloud_run_urls.json')
     agent = load_config_key("agent", vector_name=vector_name, kind="vacConfig")

{sunholo-0.64.5 → sunholo-0.64.8}/sunholo/cli/chat_vac.py

@@ -272,8 +272,9 @@ def vac_command(args):
             display_name = load_config_key("display_name", vector_name=args.vac_name,  kind="vacConfig")
             description  = load_config_key("description", vector_name=args.vac_name, kind="vacConfig")
             endpoints_config = load_config_key(agent_name, "dummy_value", kind="agentConfig")
+            post_endpoints = endpoints_config['post']
 
-            display_endpoints = ' '.join(f"{key}: {value}" for key, value in endpoints_config.items())
+            display_endpoints = ' '.join(f"{key}: {value}" for key, value in post_endpoints.items())
             display_endpoints = display_endpoints.replace("{stem}", service_url).replace("{vector_name}", args.vac_name)
 
             if agent_name == "langserve":

{sunholo-0.64.5 → sunholo-0.64.8}/sunholo/cli/cli.py

@@ -8,6 +8,7 @@ from .merge_texts import setup_merge_text_subparser
 from .run_proxy import setup_proxy_subparser
 from .chat_vac import setup_vac_subparser
 from .embedder import setup_embedder_subparser
+from .swagger import setup_swagger_subparser
 
 from ..utils.config import load_config_key
 
@@ -17,7 +18,6 @@ from .sun_rich import console
 import sys
 from rich.panel import Panel
 
-
 def load_default_gcp_config():
     try:
         gcp_config = load_config_key('gcp_config', 'global', kind="vacConfig")
@@ -82,6 +82,8 @@ def main(args=None):
     setup_vac_subparser(subparsers)
     # embed command
     setup_embedder_subparser(subparsers)
+    # swagger generation
+    setup_swagger_subparser(subparsers)
 
     #TODO: add database setup commands: alloydb and supabase
 

sunholo-0.64.8/sunholo/cli/swagger.py

@@ -0,0 +1,38 @@
+from ..agents.swagger import generate_swagger
+from ..utils.config import load_all_configs
+from .sun_rich import console
+
+def cli_swagger(args):
+
+    configs = load_all_configs()
+
+    vac_config = args.vac_config_path or configs.get('vacConfig')
+    agent_config = args.agent_config_path or configs.get('agentConfig')
+    if not agent_config:
+        raise ValueError('Need an agentConfig path')
+
+    if not vac_config:
+        raise ValueError('Need a vacConfig path')
+    
+    swag = generate_swagger(vac_config, agent_config)
+
+    console.print(swag)
+
+    return swag
+
+def setup_swagger_subparser(subparsers):
+    """
+    Sets up an argparse subparser for the 'swagger' command.
+
+    By default will use the 'vacConfig' configuration within the folder specified by '_CONFIG_FOLDER'
+
+    Example command:
+    ```bash
+    sunholo swagger --config .
+    ```
+    """
+    deploy_parser = subparsers.add_parser('swagger', help='Create a swagger specification based off a "vacConfig" configuration')
+    deploy_parser.add_argument('--vac_config_path', help='Path to the vacConfig file.  Set _CONFIG_FOLDER env var and place file in there to change default config location.')
+    deploy_parser.add_argument('--agent_config_path', help='Path to agentConfig file. Set _CONFIG_FOLDER env var and place file in there to change default config location.')
+    deploy_parser.set_defaults(func=cli_swagger)
+    

{sunholo-0.64.5 → sunholo-0.64.8}/sunholo/database/alloydb.py

@@ -234,6 +234,10 @@ def create_alloydb_table(vector_name, engine, type = "vectorstore", alloydb_conf
                 log.info(f"AlloyDB Table '{table_name}' exists in cache, skipping creation.")
 
                 return table_name
+            
+            alloydb_table_cache[table_name] = True 
+            return table_name
+            
             log.info(f"# Creating AlloyDB table {table_name}")
             try:
                 engine.init_vectorstore_table(

{sunholo-0.64.5 → sunholo-0.64.8}/sunholo/gcs/add_file.py

@@ -13,6 +13,8 @@
 #   limitations under the License.
 import datetime
 import os
+import base64
+import uuid
 
 try:
     from google.cloud import storage
@@ -22,6 +24,22 @@ except ImportError:
 from ..logging import log
 from ..utils.config import load_config_key
 
+
+def handle_base64_image(base64_data, vector_name):
+    try:
+        header, encoded = base64_data.split(",", 1)
+        data = base64.b64decode(encoded)
+
+        filename = f"{uuid.uuid4()}.jpg"
+        with open(filename, "wb") as f:
+            f.write(data)
+
+        image_uri = add_file_to_gcs(filename, vector_name)
+        os.remove(filename)  # Clean up the saved file
+        return image_uri, "image/jpeg"
+    except Exception as e:
+        raise Exception(f'Base64 image upload failed: {str(e)}')
+
 def add_file_to_gcs(filename: str, vector_name:str, bucket_name: str=None, metadata:dict=None, bucket_filepath:str=None):
 
     if not storage:

{sunholo-0.64.5 → sunholo-0.64.8}/sunholo/streaming/stream_lookup.py

@@ -5,8 +5,9 @@ def can_agent_stream(agent_name: str):
 
     log.debug(f"agent_type: {agent_name} checking streaming...")
     endpoints_config = load_config_key(agent_name, "dummy_value", kind="agentConfig")
+    post_endpoints = endpoints_config['post']
     
-    return 'stream' in endpoints_config
+    return 'stream' in post_endpoints
 
     
     

{sunholo-0.64.5 → sunholo-0.64.8}/sunholo.egg-info/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: sunholo
-Version: 0.64.5
+Version: 0.64.8
 Summary: Large Language Model DevOps - a package to help deploy LLMs to the Cloud.
 Home-page: https://github.com/sunholo-data/sunholo-py
-Download-URL: https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.64.5.tar.gz
+Download-URL: https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.64.8.tar.gz
 Author: Holosun ApS
 Author-email: multivac@sunholo.com
 License: Apache License, Version 2.0

{sunholo-0.64.5 → sunholo-0.64.8}/sunholo.egg-info/SOURCES.txt

@@ -18,6 +18,7 @@ sunholo/agents/langserve.py
 sunholo/agents/pubsub.py
 sunholo/agents/route.py
 sunholo/agents/special_commands.py
+sunholo/agents/swagger.py
 sunholo/agents/fastapi/__init__.py
 sunholo/agents/fastapi/base.py
 sunholo/agents/fastapi/qna_routes.py
@@ -51,6 +52,7 @@ sunholo/cli/embedder.py
 sunholo/cli/merge_texts.py
 sunholo/cli/run_proxy.py
 sunholo/cli/sun_rich.py
+sunholo/cli/swagger.py
 sunholo/components/__init__.py
 sunholo/components/llm.py
 sunholo/components/retriever.py
@@ -116,4 +118,5 @@ sunholo/vertex/safety.py
 tests/test_chat_history.py
 tests/test_chunker.py
 tests/test_config.py
-tests/test_dispatch_to_qa.py
+tests/test_dispatch_to_qa.py
+tests/test_swagger.py

sunholo-0.64.8/tests/test_swagger.py

@@ -0,0 +1,15 @@
+from sunholo.agents import config_to_swagger
+import yaml
+
+
+# Test cases for config_to_swagger and generate_swagger functions
+def test_config_to_swagger():
+    swagger_yaml = config_to_swagger()
+    swagger_dict = yaml.safe_load(swagger_yaml)
+    
+    assert 'swagger' in swagger_dict
+    assert swagger_dict['swagger'] == '2.0'
+    assert 'info' in swagger_dict
+    assert swagger_dict['info']['title'] == 'Multivac - Cloud Endpoints + Cloud Run'
+    assert 'paths' in swagger_dict
+    #TODO: more tests for specific agents