code: def test_gradio_vllm_docker(base_model):
      # HF inference server
      gradio_port = get_inf_port()
      inf_port = gradio_port + 1
      inference_server = "vllm:127.0.0.1:%s" % inf_port
      if "llama" in base_model:
          tokenizer = "hf-internal-testing/llama-tokenizer"
      else:
          tokenizer = None
  
      docker_hash1 = run_vllm_docker(inf_port, base_model, tokenizer)
      os.system("docker logs %s | tail -10" % docker_hash1)
  
      # h2oGPT server
      docker_hash2 = run_h2ogpt_docker(
          gradio_port, base_model, inference_server=inference_server
      )
      time.sleep(
          30
      )  # assumes image already downloaded, else need more time
      os.system("docker logs %s | tail -10" % docker_hash2)
  
      # test this version for now, until docker updated
      version = 1
  
      try:
          # client test to server that only consumes inference server
          prompt = "Who are you?"
          print(
              "Starting client tests with prompt: %s using %s"
              % (prompt, get_inf_server())
          )
          from src.client_test import run_client_chat
  
          res_dict, client = run_client_chat(
              prompt=prompt,
              stream_output=True,
              max_new_tokens=256,
              langchain_mode="Disabled",
              langchain_action=LangChainAction.QUERY.value,
              langchain_agents=[],
              version=version,
          )
          assert res_dict["prompt"] == prompt
          assert res_dict["iinput"] == ""
  
          # will use HOST from above
          # client shouldn't have to specify
          ret1, ret2, ret3, ret4, ret5, ret6, ret7 = run_client_many(
              prompt_type=None, version=version
          )
          if "llama" in base_model.lower():
              who = "I'm LLaMA, an AI assistant developed by Meta AI"
              assert who in ret1["response"]
              assert who in ret1["response"]
              assert "Once upon a time" in ret2["response"]
              assert "Once upon a time" in ret3["response"]
              assert who in ret4["response"]
              assert who in ret5["response"]
              assert who in ret6["response"]
              assert who in ret7["response"]
          else:
              who = "I am an AI language model"
              assert who in ret1["response"]
              assert "Once upon a time" in ret2["response"]
              assert "Once upon a time" in ret3["response"]
              assert who in ret4["response"]
              assert who in ret5["response"]
              assert who in ret6["response"]
              assert who in ret7["response"]
          print("DONE", flush=True)
      finally:
          os.system("docker stop %s" % docker_hash1)
          os.system("docker stop %s" % docker_hash2)
  
imports: import os
  import subprocess
  import time
  from datetime import datetime
  import pytest
  from src.utils import get_ngpus_vis, makedirs
  from tests.utils import wrap_test_forked, get_inf_port, get_inf_server
  from tests.test_langchain_units import have_openai_key, have_replicate_key
  from src.client_test import run_client_many, test_client_basic_api_lean
  from src.enums import PromptType, LangChainAction
label_desc: Use image node_id 9 for calling a global function with example usage: test_gradio_vllm_docker(base_model) without return types