# Example variables
model_name = "phi-3-ov"
prompt = "Explain quantum computing in simple terms"
max_output = 300
temperature = 0.7

print("\nStarting 'Create stream'")
print(f"Model_name: {model_name}")
print(f"Prompt: {prompt}")
print(f"Max_output: {max_output}")
print(f"Temperature: {temperature}")

# This is the streaming stream API
stream = client.stream(model_name=model_name, prompt=prompt, max_output=max_output, temperature=temperature)
for chunk in stream:
    print(chunk)

// Streaming response format
data: {"llm_response": "Quantum computing is a revolutionary approach..."}

# Example variables
prompt = "Write a short story about artificial intelligence"
model_name = "llama-3.2-3b-instruct-ov"
max_output = 100
temperature = 0.8

print("\nStarting 'Create inference'")
print(f"Prompt: {prompt}")
print(f"Model_name: {model_name}")
print(f"Max_output: {max_output}")
print(f"Temperature: {temperature}")

# This is the main inference API
response = client.inference(prompt=prompt, model_name=model_name, max_output=max_output, temperature=temperature)
print("\nCreate inference response: ", response)

{
  "llm_response": "Artificial intelligence represents one of humanity's greatest..."
}

# Example variables
model_name = "phi-3-ov"
context = "John Smith works at Acme Corp as a Software Engineer. He can be reached at john@acme.com."
function = "extract_entities"

print("\nStarting 'Function call'")
print(f"Model_name: {model_name}")
print(f"Context: {context}")
print(f"Function: {function}")

# This is the main function_call API
response = client.function_call(model_name=model_name, context=context, function=function)
print("\nFunction call response: ", response)

{
  "llm_response": {
    "name": "John Smith",
    "company": "Acme Corp",
    "role": "Software Engineer",
    "email": "john@acme.com"
  }
}

# Example variables
context = "I absolutely love this new product! It's amazing and works perfectly."

print("\nStarting 'Sentiment analysis'")
print(f"Context: {context}")

# This is the main sentiment API
response = client.sentiment(context=context)
print("\nSentiment analysis response: ", response)

{
  "llm_response": {
    "sentiment": "positive",
    "confidence": 0.95
  }
}

# Example variables
context = "Invoice #12345 dated March 15, 2024. Total amount: $1,250.00. Customer: ABC Corp."
extract_keys = ["invoice_number","date","total_amount","customer"]

print("\nStarting 'Extract information'")
print(f"Context: {context}")
print(f"Extract_keys: {extract_keys}")

# This is the main extract API
response = client.extract(context=context, extract_keys=extract_keys)
print("\nExtract information response: ", response)

{
  "llm_response": {
    "invoice_number": "12345",
    "date": "March 15, 2024",
    "total_amount": "$1,250.00",
    "customer": "ABC Corp"
  }
}

# Example variables
uploaded_files = ["image1.jpg"]
prompt = "Describe what you see in this image"
model_name = "mistral-7b-instruct-v0.3-ov"

print("\nStarting 'Vision inference'")
print(f"Uploaded_files: {uploaded_files}")
print(f"Prompt: {prompt}")
print(f"Model_name: {model_name}")

# This is the main vision API
response = client.vision(uploaded_files=uploaded_files, prompt=prompt, model_name=model_name)
print("\nVision inference response: ", response)

{
  "llm_response": "I can see a beautiful landscape with mountains in the background..."
}

# Example variables
uploaded_files = ["image1.jpg"]
model_name = "llama-3.2-3b-instruct-ov"
prompt = "Analyze this image and describe the scene"

print("\nStarting 'Vision stream'")
print(f"Uploaded_files: {uploaded_files}")
print(f"Model_name: {model_name}")
print(f"Prompt: {prompt}")

# This is the streaming vision_stream API
stream = client.vision_stream(uploaded_files=uploaded_files, model_name=model_name, prompt=prompt)
for chunk in stream:
    print(chunk)

// Streaming response format
data: {"llm_response": "The image shows a bustling city street..."}

# Example variables
query = "machine learning algorithms"
documents = ["Document about neural networks","Article on cooking recipes","Paper on deep learning"]

print("\nStarting 'Semantic ranking'")
print(f"Query: {query}")
print(f"Documents: {documents}")

# This is the main rank API
response = client.rank(query=query, documents=documents)
print("\nSemantic ranking response: ", response)

{
  "llm_response": [
    {
      "doc_id": 0,
      "score": 0.95
    },
    {
      "doc_id": 2,
      "score": 0.87
    },
    {
      "doc_id": 1,
      "score": 0.12
    }
  ]
}

# Example variables
model_name = "phi-4-ov"
context = "This is a sample text to classify for safety"

print("\nStarting 'Text classification'")
print(f"Model_name: {model_name}")
print(f"Context: {context}")

# This is the main classify API
response = client.classify(model_name=model_name, context=context)
print("\nText classification response: ", response)

{
  "llm_response": {
    "classification": "safe",
    "confidence": 0.98
  }
}

# Example variables
model_name = "llama-3.2-3b-instruct-ov"
context = "This is a sample text to embed"

print("\nStarting 'Generate embeddings'")
print(f"Model_name: {model_name}")
print(f"Context: {context}")

# This is the main embedding API
response = client.embedding(model_name=model_name, context=context)
print("\nGenerate embeddings response: ", response)

{
  "embeddings": [
    0.1,
    -0.2,
    0.3,
    0.4,
    -0.1
  ]
}

# Example variables


print("\nStarting 'List models'")


# This is the main list_all_models API
response = client.list_all_models()
print("\nList models response: ", response)

{
  "response": [
    "llama-3.2-1b-instruct-ov",
    "llama-3.2-3b-instruct-ov",
    "mistral-7b-instruct-v0.3-ov",
    "phi-4-ov"
  ]
}

# Example variables


print("\nStarting 'System information'")


# This is the main system_info API
response = client.system_info()
print("\nSystem information response: ", response)

{
  "response": {
    "version": "1.0.0",
    "gpu_count": 2,
    "memory": "32GB",
    "status": "active"
  }
}

# Example variables
model_name = "mistral-7b-instruct-v0.3-ov"

print("\nStarting 'Model information'")
print(f"Model_name: {model_name}")

# This is the main model_lookup API
response = client.model_lookup(model_name=model_name)
print("\nModel information response: ", response)

{
  "response": {
    "name": "mistral-7b-instruct-v0.3-ov",
    "parameters": "7B",
    "context_length": 4096,
    "loaded": true
  }
}

# Example variables
model_name = "phi-4-ov"

print("\nStarting 'Load model'")
print(f"Model_name: {model_name}")

# This is the main model_load API
response = client.model_load(model_name=model_name)
print("\nLoad model response: ", response)

{
  "response": {
    "model_name": "phi-4-ov",
    "status": "loaded",
    "memory_usage": "6.2GB"
  }
}

# Example variables
model_name = "llama-3.2-1b-instruct-ov"

print("\nStarting 'Unload model'")
print(f"Model_name: {model_name}")

# This is the main model_unload API
response = client.model_unload(model_name=model_name)
print("\nUnload model response: ", response)

{
  "response": {
    "model_name": "llama-3.2-1b-instruct-ov",
    "status": "unloaded",
    "memory_freed": "6.2GB"
  }
}

# Example variables
prompt = "Write a short story about artificial intelligence"
model_name = "llama-3.2-3b-instruct-ov"
max_output = 100
temperature = 0.8

print("\nStarting 'Inference with JSON'")
print(f"Prompt: {prompt}")
print(f"Model_name: {model_name}")
print(f"Max_output: {max_output}")
print(f"Temperature: {temperature}")

# This is the main inference_json API
response = client.inference_json(prompt=prompt, model_name=model_name, max_output=max_output, temperature=temperature)
print("\nInference with JSON response: ", response)

{
  "llm_response": "Artificial intelligence represents one of humanity's greatest..."
}

# Example variables
prompt = "A serene mountain landscape at sunset"
model_name = "sd-xl"

print("\nStarting 'Generate image'")
print(f"Prompt: {prompt}")
print(f"Model_name: {model_name}")

# This is the main generate_image API
response = client.generate_image(prompt=prompt, model_name=model_name)
print("\nGenerate image response: ", response)

{
  "fp": "/path/to/generated/image.bmp"
}

# Example variables
prompt = "Hello, welcome to Model HQ. This is a text to speech demonstration."
model_name = "tts-model"

print("\nStarting 'Generate speech'")
print(f"Prompt: {prompt}")
print(f"Model_name: {model_name}")

# This is the main generate_speech API
response = client.generate_speech(prompt=prompt, model_name=model_name)
print("\nGenerate speech response: ", response)

{
  "fp": "/path/to/generated/speech.wav"
}

# Example variables
model_name = "llama-3.2-1b-instruct-ov"

print("\nStarting 'Download model'")
print(f"Model_name: {model_name}")

# This is the main model_download API
response = client.model_download(model_name=model_name)
print("\nDownload model response: ", response)

{
  "response": {
    "status": "success",
    "zip_fp": "/path/to/downloaded/model.zip"
  }
}

# Example variables
model_name = "llama-3.2-3b-instruct-ov"
test_file = "test_suite.jsonl"

print("\nStarting 'Batch test'")
print(f"Model_name: {model_name}")
print(f"Test_file: {test_file}")

# This is the main test_batch API
response = client.test_batch(model_name=model_name, test_file=test_file)
print("\nBatch test response: ", response)

{
  "test_results": {
    "total": 100,
    "passed": 95,
    "failed": 5,
    "accuracy": 0.95
  }
}

# Example variables
model_name = "llama-3.2-3b-instruct-ov"
test_file = "test_suite.jsonl"

print("\nStarting 'Test model'")
print(f"Model_name: {model_name}")
print(f"Test_file: {test_file}")

# This is the main test API
response = client.test(model_name=model_name, test_file=test_file)
print("\nTest model response: ", response)

{
  "test_results": [
    {
      "test_id": 1,
      "passed": true,
      "output": "..."
    },
    {
      "test_id": 2,
      "passed": false,
      "output": "..."
    }
  ]
}

# Example variables
question = "What is the main conclusion of this research paper?"
uploaded_document = "research_paper.pdf"
model_name = "phi-3-ov"

print("\nStarting 'Document Q&A'")
print(f"Question: {question}")
print(f"Uploaded_document: {uploaded_document}")
print(f"Model_name: {model_name}")

# This is the main document_inference API
response = client.document_inference(question=question, uploaded_document=uploaded_document, model_name=model_name)
print("\nDocument Q&A response: ", response)

{
  "response": "Based on the document analysis, the main conclusion is..."
}

# Example variables
question = "What are the key features of the product?"
library_name = "product_docs"
model_name = "llama-3.2-3b-instruct-ov"

print("\nStarting 'Library Q&A'")
print(f"Question: {question}")
print(f"Library_name: {library_name}")
print(f"Model_name: {model_name}")

# This is the main library_inference API
response = client.library_inference(question=question, library_name=library_name, model_name=model_name)
print("\nLibrary Q&A response: ", response)

{
  "response": "Based on the library content, the key features include..."
}

# Example variables
uploaded_files = ["contract1.pdf","contract2.pdf"]
question_list = ["What is the governing law?","What is the termination notice period?"]
model_name = "mistral-7b-instruct-v0.3-ov"

print("\nStarting 'Batch document analysis'")
print(f"Uploaded_files: {uploaded_files}")
print(f"Question_list: {question_list}")
print(f"Model_name: {model_name}")

# This is the main document_batch_analysis API
response = client.document_batch_analysis(uploaded_files=uploaded_files, question_list=question_list, model_name=model_name)
print("\nBatch document analysis response: ", response)

{
  "response": {
    "results": [
      {
        "document": "contract1.pdf",
        "answers": [
          "Delaware",
          "30 days"
        ]
      },
      {
        "document": "contract2.pdf",
        "answers": [
          "California",
          "60 days"
        ]
      }
    ]
  }
}

# Example variables
question = "What are the key features of the product?"
library_name = "product_docs"
model_name = "llama-3.2-3b-instruct-ov"

print("\nStarting 'Library stream'")
print(f"Question: {question}")
print(f"Library_name: {library_name}")
print(f"Model_name: {model_name}")

# This is the streaming library_stream_inference API
stream = client.library_stream_inference(question=question, library_name=library_name, model_name=model_name)
for chunk in stream:
    print(chunk)

// Streaming response format
data: {"llm_response": "Based on the library content, the key features include..."}

# Example variables
uploaded_files = ["document1.pdf","document2.pdf"]
text_chunk_size = 500

print("\nStarting 'Build source'")
print(f"Uploaded_files: {uploaded_files}")
print(f"Text_chunk_size: {text_chunk_size}")

# This is the main build_source API
response = client.build_source(uploaded_files=uploaded_files, text_chunk_size=text_chunk_size)
print("\nBuild source response: ", response)

{
  "response": "/path/to/source/my_source.jsonl"
}

# Example variables
uploaded_source = "my_source.jsonl"
question = "What are the termination clauses?"
use_top_n_context = 6

print("\nStarting 'Build source context'")
print(f"Uploaded_source: {uploaded_source}")
print(f"Question: {question}")
print(f"Use_top_n_context: {use_top_n_context}")

# This is the main build_source_context API
response = client.build_source_context(uploaded_source=uploaded_source, question=question, use_top_n_context=use_top_n_context)
print("\nBuild source context response: ", response)

{
  "response": [
    {
      "doc_id": 1,
      "text": "Relevant passage from the source...",
      "score": 0.95,
      "page_num": 3
    }
  ]
}

# Example variables
uploaded_source = "my_source.jsonl"
question = "What are the key conclusions?"
model_name = "llama-3.2-3b-instruct-ov"
use_top_n_context = 6

print("\nStarting 'Source Q&A'")
print(f"Uploaded_source: {uploaded_source}")
print(f"Question: {question}")
print(f"Model_name: {model_name}")
print(f"Use_top_n_context: {use_top_n_context}")

# This is the main source_inference API
response = client.source_inference(uploaded_source=uploaded_source, question=question, model_name=model_name, use_top_n_context=use_top_n_context)
print("\nSource Q&A response: ", response)

{
  "llm_response": "Based on the source content, the key conclusions are..."
}

# Example variables
uploaded_source = "my_source.jsonl"
question = "What are the key conclusions?"
model_name = "llama-3.2-3b-instruct-ov"
use_top_n_context = 6

print("\nStarting 'Source stream'")
print(f"Uploaded_source: {uploaded_source}")
print(f"Question: {question}")
print(f"Model_name: {model_name}")
print(f"Use_top_n_context: {use_top_n_context}")

# This is the streaming source_stream_inference API
stream = client.source_stream_inference(uploaded_source=uploaded_source, question=question, model_name=model_name, use_top_n_context=use_top_n_context)
for chunk in stream:
    print(chunk)

// Streaming response format
data: {"llm_response": "Based on the source content, the key conclusions are..."}

# Example variables
test_file = "evaluation_data.jsonl"
dataset_name = "contract_qa_v1"

print("\nStarting 'Predictive model inference'")
print(f"Test_file: {test_file}")
print(f"Dataset_name: {dataset_name}")

# This is the main inference_predictive_model API
response = client.inference_predictive_model(test_file=test_file, dataset_name=dataset_name)
print("\nPredictive model inference response: ", response)

{
  "results": {
    "accuracy": 0.92,
    "total_samples": 100,
    "passed": 92
  }
}

# Example variables
library_name = "contract_library"
account_name = "user123"
db = "mongo"

print("\nStarting 'Create library'")
print(f"Library_name: {library_name}")
print(f"Account_name: {account_name}")
print(f"Db: {db}")

# This is the main create_new_library API
response = client.create_new_library(library_name=library_name, account_name=account_name, db=db)
print("\nCreate library response: ", response)

{
  "response": {
    "library_name": "contract_library",
    "status": "created",
    "doc_count": 0
  }
}

# Example variables
library_name = "contract_library"
uploaded_files = ["contract1.pdf","contract2.pdf"]

print("\nStarting 'Add files to library'")
print(f"Library_name: {library_name}")
print(f"Uploaded_files: {uploaded_files}")

# This is the main add_files API
response = client.add_files(library_name=library_name, uploaded_files=uploaded_files)
print("\nAdd files to library response: ", response)

{
  "response": {
    "files_processed": 2,
    "chunks_created": 45,
    "status": "completed"
  }
}

# Example variables
library_name = "contract_library"
account_name = "user123"
user_query = "termination clauses"
result_count = 10

print("\nStarting 'Query library'")
print(f"Library_name: {library_name}")
print(f"Account_name: {account_name}")
print(f"User_query: {user_query}")
print(f"Result_count: {result_count}")

# This is the main query API
response = client.query(library_name=library_name, account_name=account_name, user_query=user_query, result_count=result_count)
print("\nQuery library response: ", response)

{
  "response": [
    {
      "doc_id": 1,
      "text": "Termination clause content...",
      "score": 0.95
    }
  ]
}

# Example variables
library_name = "contract_library"
account_name = "user123"
db = "mongo"

print("\nStarting 'Get library info'")
print(f"Library_name: {library_name}")
print(f"Account_name: {account_name}")
print(f"Db: {db}")

# This is the main get_library_card API
response = client.get_library_card(library_name=library_name, account_name=account_name, db=db)
print("\nGet library info response: ", response)

{
  "response": {
    "library_name": "contract_library",
    "doc_count": 25,
    "embedding_status": "installed",
    "created_date": "2024-01-15"
  }
}

# Example variables
library_name = "contract_library"
account_name = "user123"
model_name = "all-mini-lm-l6-v2-ov"
vector_db = "milvus"
db = "mongo"

print("\nStarting 'Install embeddings'")
print(f"Library_name: {library_name}")
print(f"Account_name: {account_name}")
print(f"Model_name: {model_name}")
print(f"Vector_db: {vector_db}")
print(f"Db: {db}")

# This is the main install_embedding API
response = client.install_embedding(library_name=library_name, account_name=account_name, model_name=model_name, vector_db=vector_db, db=db)
print("\nInstall embeddings response: ", response)

{
  "response": {
    "embeddings_created": 1250,
    "vector_db": "milvus",
    "status": "completed"
  }
}

# Example variables
library_name = "contract_library"
user_query = "contract termination conditions"
account_name = "user123"
vector_db = "milvus"
db = "mongo"
embedding_model = "all-mini-lm-l6-v2-ov"
result_count = 5

print("\nStarting 'Semantic search'")
print(f"Library_name: {library_name}")
print(f"User_query: {user_query}")
print(f"Account_name: {account_name}")
print(f"Vector_db: {vector_db}")
print(f"Db: {db}")
print(f"Embedding_model: {embedding_model}")
print(f"Result_count: {result_count}")

# This is the main semantic_query API
response = client.semantic_query(library_name=library_name, user_query=user_query, account_name=account_name, vector_db=vector_db, db=db, embedding_model=embedding_model, result_count=result_count)
print("\nSemantic search response: ", response)

{
  "response": [
    {
      "doc_id": 1,
      "similarity_score": 0.92,
      "text": "Contract termination..."
    }
  ]
}

# Example variables
library_name = "contract_library"
account_name = "user123"
db = "mongo"

print("\nStarting 'List documents'")
print(f"Library_name: {library_name}")
print(f"Account_name: {account_name}")
print(f"Db: {db}")

# This is the main get_document_list API
response = client.get_document_list(library_name=library_name, account_name=account_name, db=db)
print("\nList documents response: ", response)

{
  "response": [
    {
      "doc_id": 1,
      "filename": "contract1.pdf",
      "pages": 12,
      "upload_date": "2024-01-15"
    },
    {
      "doc_id": 2,
      "filename": "contract2.pdf",
      "pages": 8,
      "upload_date": "2024-01-16"
    }
  ]
}

# Example variables
library_name = "contract_library"
account_name = "user123"
db = "mongo"
doc_id = "1"

print("\nStarting 'Extract document text'")
print(f"Library_name: {library_name}")
print(f"Account_name: {account_name}")
print(f"Db: {db}")
print(f"Doc_id: {doc_id}")

# This is the main get_document_text API
response = client.get_document_text(library_name=library_name, account_name=account_name, db=db, doc_id=doc_id)
print("\nExtract document text response: ", response)

{
  "response": {
    "doc_id": 1,
    "filename": "contract1.pdf",
    "text": "Full document text content..."
  }
}

# Example variables
library_name = "contract_library"
uploaded_files = ["contract1.pdf","contract2.pdf"]
account_name = "user123"
db = "mongo"

print("\nStarting 'Add files async'")
print(f"Library_name: {library_name}")
print(f"Uploaded_files: {uploaded_files}")
print(f"Account_name: {account_name}")
print(f"Db: {db}")

# This is the main add_files_async API
response = client.add_files_async(library_name=library_name, uploaded_files=uploaded_files, account_name=account_name, db=db)
print("\nAdd files async response: ", response)

{
  "response": {
    "status": "queued",
    "message": "Files added for processing"
  }
}

# Example variables
library_name = "contract_library"
account_name = "user123"
model_name = "all-mini-lm-l6-v2-ov"
vector_db = "milvus"
db = "mongo"

print("\nStarting 'Install embeddings async'")
print(f"Library_name: {library_name}")
print(f"Account_name: {account_name}")
print(f"Model_name: {model_name}")
print(f"Vector_db: {vector_db}")
print(f"Db: {db}")

# This is the main install_embedding_async API
response = client.install_embedding_async(library_name=library_name, account_name=account_name, model_name=model_name, vector_db=vector_db, db=db)
print("\nInstall embeddings async response: ", response)

{
  "response": {
    "embedding_record": {},
    "status": "started"
  }
}

# Example variables


print("\nStarting 'List all agents'")


# This is the main get_all_agents API
response = client.get_all_agents()
print("\nList all agents response: ", response)

{
  "response": [
    {
      "name": "contract_analyzer",
      "description": "Contract analysis agent",
      "version": "1.2.0"
    },
    {
      "name": "invoice_processor",
      "description": "Invoice processing agent",
      "version": "1.0.1"
    }
  ]
}

# Example variables
process_name = "contract_analyzer"

print("\nStarting 'Get agent signature'")
print(f"Process_name: {process_name}")

# This is the main get_agent_signature API
response = client.get_agent_signature(process_name=process_name)
print("\nGet agent signature response: ", response)

{
  "agent_signature": {
    "name": "contract_analyzer",
    "inputs": [
      [
        "User-Document",
        "document",
        ""
      ]
    ],
    "outputs": [
      "analysis_report"
    ],
    "description": "Analyzes contracts for key terms",
    "steps": 4,
    "updatable_parameters": [
      "model_name",
      "temperature"
    ]
  }
}

# Example variables
process_name = "contract_analyzer"

print("\nStarting 'Get agent description'")
print(f"Process_name: {process_name}")

# This is the main get_agent_description API
response = client.get_agent_description(process_name=process_name)
print("\nGet agent description response: ", response)

{
  "agent_description": "This agent analyzes a contract document and extracts key terms including effective date, base salary, and termination provisions."
}

# Example variables
process_name = "contract_analyzer"
document_file = "contract.pdf"

print("\nStarting 'Execute agent'")
print(f"Process_name: {process_name}")
print(f"Document_file: {document_file}")

# This is the main run_agent API
response = client.run_agent(process_name=process_name, document_file=document_file)
print("\nExecute agent response: ", response)

{
  "agent_output": {
    "agent_name": "contract_analyzer",
    "status": "completed",
    "execution_id": "d0f1ebb5-66ce-47e6-b1c0-f5767a88491e",
    "execution_time": "45s"
  }
}

# Example variables
agent_name = "contract_analyzer"
agent_inputs = {"User-Document":"contract.pdf"}

print("\nStarting 'Execute agent with streaming'")
print(f"Agent_name: {agent_name}")
print(f"Agent_inputs: {agent_inputs}")

# This is the streaming run_agent_generator API
stream = client.run_agent_generator(agent_name=agent_name, agent_inputs=agent_inputs)
for chunk in stream:
    print(chunk)

// Streaming response format
data: {"llm_response": """"}

# Example variables
agent_name = "contract_analyzer"
agent_inputs = {"User-Document":"contract.pdf"}
run_async = false

print("\nStarting 'Call agent endpoint'")
print(f"Agent_name: {agent_name}")
print(f"Agent_inputs: {agent_inputs}")
print(f"Run_async: {run_async}")

# This is the main call_agent API
response = client.call_agent(agent_name=agent_name, agent_inputs=agent_inputs, run_async=run_async)
print("\nCall agent endpoint response: ", response)

{
  "response": {
    "execution_id": "d0f1ebb5-66ce-47e6-b1c0-f5767a88491e",
    "status": "completed"
  }
}

# Example variables
id = "d0f1ebb5-66ce-47e6-b1c0-f5767a88491e"

print("\nStarting 'Get agent output'")
print(f"Id: {id}")

# This is the main agent_output API
response = client.agent_output(id=id)
print("\nGet agent output response: ", response)

{
  "response": {
    "status": "completed",
    "output": "Agent analysis completed successfully"
  }
}

# Example variables
id = "d0f1ebb5-66ce-47e6-b1c0-f5767a88491e"

print("\nStarting 'Get agent output (JSON)'")
print(f"Id: {id}")

# This is the main get_agent_output_json API
response = client.get_agent_output_json(id=id)
print("\nGet agent output (JSON) response: ", response)

{
  "response": {
    "effective_date": "2024-01-01",
    "base_salary": "$150,000",
    "termination_notice": "30 days"
  }
}

# Example variables
id = "d0f1ebb5-66ce-47e6-b1c0-f5767a88491e"

print("\nStarting 'Get agent output (files)'")
print(f"Id: {id}")

# This is the main get_agent_output_files API
response = client.get_agent_output_files(id=id)
print("\nGet agent output (files) response: ", response)

{
  "response": {
    "status": "success",
    "zip_fp": "/path/to/agent_output_d0f1ebb5.zip"
  }
}

# Example variables
agent_name = "contract_analyzer"

print("\nStarting 'Get agent execution logs'")
print(f"Agent_name: {agent_name}")

# This is the main get_agent_execution_log_list API
response = client.get_agent_execution_log_list(agent_name=agent_name)
print("\nGet agent execution logs response: ", response)

{
  "agent_logs": [
    {
      "execution_id": "d0f1ebb5-66ce-47e6-b1c0-f5767a88491e",
      "status": "completed",
      "timestamp": "2024-01-15T10:30:00Z"
    }
  ]
}

# Example variables
process_zip = "contract_analyzer.zip"

print("\nStarting 'Install agent'")
print(f"Process_zip: {process_zip}")

# This is the main install_agent API
response = client.install_agent(process_zip=process_zip)
print("\nInstall agent response: ", response)

{
  "agent_details": {
    "process_name": "contract_analyzer",
    "status": "installed"
  }
}

# Example variables
process_name = "contract_analyzer"

print("\nStarting 'Download agent'")
print(f"Process_name: {process_name}")

# This is the main download_agent API
response = client.download_agent(process_name=process_name)
print("\nDownload agent response: ", response)

{
  "response": {
    "status": "success",
    "zip_fp": "/path/to/contract_analyzer.zip"
  }
}

# Example variables


print("\nStarting 'Get all scheduled agents'")


# This is the main get_all_scheduled_agents API
response = client.get_all_scheduled_agents()
print("\nGet all scheduled agents response: ", response)

{
  "scheduled_agents": [
    {
      "agent_name": "daily_report",
      "frequency": "daily",
      "next_run": "2024-01-16T09:00:00Z"
    }
  ]
}

# Example variables
agent_name = "daily_report"
frequency = "daily"
hour = 9
minute = 0

print("\nStarting 'Schedule agent'")
print(f"Agent_name: {agent_name}")
print(f"Frequency: {frequency}")
print(f"Hour: {hour}")
print(f"Minute: {minute}")

# This is the main set_new_agent_schedule API
response = client.set_new_agent_schedule(agent_name=agent_name, frequency=frequency, hour=hour, minute=minute)
print("\nSchedule agent response: ", response)

{
  "new_schedule": {
    "agent_name": "daily_report",
    "frequency": "daily",
    "status": "scheduled"
  }
}

# Example variables


print("\nStarting 'Health check'")


# This is the main ping API
response = client.ping()
print("\nHealth check response: ", response)

{
  "response": {
    "status": "ok",
    "timestamp": "2024-01-15T10:30:00Z",
    "version": "1.0.0"
  }
}

# Example variables


print("\nStarting 'Stop server'")


# This is the main server_stop API
response = client.server_stop()
print("\nStop server response: ", response)

{
  "response": {
    "status": "stopping",
    "message": "Server shutdown initiated"
  }
}

# Example variables


print("\nStarting 'API catalog'")


# This is the main get_api_catalog API
response = client.get_api_catalog()
print("\nAPI catalog response: ", response)

{
  "response": [
    {
      "api_name": "inference",
      "endpoint": "/inference/",
      "method": "POST",
      "timeout": 60
    },
    {
      "api_name": "stream",
      "endpoint": "/stream/",
      "method": "POST",
      "timeout": 60
    }
  ]
}

# Example variables


print("\nStarting 'Database info'")


# This is the main get_db_info API
response = client.get_db_info()
print("\nDatabase info response: ", response)

{
  "response": {
    "databases": [
      "mongo",
      "sqlite"
    ],
    "vector_databases": [
      "milvus",
      "faiss"
    ],
    "default_db": "mongo",
    "default_vector_db": "milvus"
  }
}

# Example variables


print("\nStarting 'App registration'")


# This is the main app_register API
response = client.app_register()
print("\nApp registration response: ", response)

{
  "status": "registered"
}

# Example variables
user_name = "jane_doe"
user_email = "jane@example.com"
user_token = "setup-token"

print("\nStarting 'Register new user'")
print(f"User_name: {user_name}")
print(f"User_email: {user_email}")
print(f"User_token: {user_token}")

# This is the main register_new_user API
response = client.register_new_user(user_name=user_name, user_email=user_email, user_token=user_token)
print("\nRegister new user response: ", response)

{
  "credentials": {
    "api_key": "new-api-key",
    "user_id": "user_12345"
  }
}

# Example variables


print("\nStarting 'Transaction log'")


# This is the main get_transaction_log API
response = client.get_transaction_log()
print("\nTransaction log response: ", response)

{
  "logs": [
    {
      "timestamp": "2024-01-15T10:30:00Z",
      "endpoint": "/inference/",
      "user": "user_12345"
    }
  ]
}

# Example variables
credentials = {"tavily_api_key":"tvly-..."}

print("\nStarting 'Add credential'")
print(f"Credentials: {credentials}")

# This is the main add_credential API
response = client.add_credential(credentials=credentials)
print("\nAdd credential response: ", response)

{
  "response": {
    "status": "added",
    "credentials": [
      "tavily_api_key"
    ]
  }
}

# Example variables
credential_name = "tavily_api_key"

print("\nStarting 'Delete credential'")
print(f"Credential_name: {credential_name}")

# This is the main delete_credential API
response = client.delete_credential(credential_name=credential_name)
print("\nDelete credential response: ", response)

{
  "response": {
    "status": "deleted"
  }
}

# Example variables
service_name = "custom_analyzer"
service_dfn = "{...}"

print("\nStarting 'Install service'")
print(f"Service_name: {service_name}")
print(f"Service_dfn: {service_dfn}")

# This is the main install_service API
response = client.install_service(service_name=service_name, service_dfn=service_dfn)
print("\nInstall service response: ", response)

{
  "response": {
    "service_name": "custom_analyzer",
    "status": "installed"
  }
}

# Example variables


print("\nStarting 'List services'")


# This is the main list_services API
response = client.list_services()
print("\nList services response: ", response)

{
  "response": [
    {
      "service_name": "custom_analyzer",
      "status": "active"
    }
  ]
}

# Example variables
service_name = "custom_analyzer"

print("\nStarting 'Test service'")
print(f"Service_name: {service_name}")

# This is the main test_service API
response = client.test_service(service_name=service_name)
print("\nTest service response: ", response)

{
  "response": {
    "service_name": "custom_analyzer",
    "status": "operational"
  }
}

# Example variables


print("\nStarting 'List integrations'")


# This is the main list_integrations API
response = client.list_integrations()
print("\nList integrations response: ", response)

{
  "response": [
    {
      "name": "tavily",
      "type": "web_search",
      "status": "configured"
    }
  ]
}

# Example variables
integration_name = "tavily"

print("\nStarting 'Get integration info'")
print(f"Integration_name: {integration_name}")

# This is the main get_integration_info API
response = client.get_integration_info(integration_name=integration_name)
print("\nGet integration info response: ", response)

{
  "response": {
    "name": "tavily",
    "type": "web_search",
    "status": "configured",
    "capabilities": [
      "web_search"
    ]
  }
}

# Example variables
query = "What is quantum gravity?"
engine = "tavily"
result_count = 5

print("\nStarting 'Web search'")
print(f"Query: {query}")
print(f"Engine: {engine}")
print(f"Result_count: {result_count}")

# This is the main web_search API
response = client.web_search(query=query, engine=engine, result_count=result_count)
print("\nWeb search response: ", response)

{
  "response": [
    {
      "title": "Quantum Gravity Explained",
      "url": "https://example.com/quantum-gravity",
      "snippet": "Quantum gravity is..."
    }
  ]
}

# Example variables
app_name = "contract_review"

print("\nStarting 'Start app session'")
print(f"App_name: {app_name}")

# This is the main start_app_session API
response = client.start_app_session(app_name=app_name)
print("\nStart app session response: ", response)

{
  "session_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "status": "started"
}

# Example variables
session_id = "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
user_msg = "What is the annual rate of the base salary?"

print("\nStarting 'Chat'")
print(f"Session_id: {session_id}")
print(f"User_msg: {user_msg}")

# This is the streaming chat API
stream = client.chat(session_id=session_id, user_msg=user_msg)
for chunk in stream:
    print(chunk)

// Streaming response format
data: {"llm_response": "{"text":"The annual base salary is $150,000...","sources":[""}

data: {"llm_response": "contract.pdf"]}"}

# Example variables
session_id = "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
agent_name = "contract_analyzer"
inputs = {"User-Document":"contract.pdf"}

print("\nStarting 'Run app agent'")
print(f"Session_id: {session_id}")
print(f"Agent_name: {agent_name}")
print(f"Inputs: {inputs}")

# This is the streaming run_app_agent API
stream = client.run_app_agent(session_id=session_id, agent_name=agent_name, inputs=inputs)
for chunk in stream:
    print(chunk)

// Streaming response format
data: {"llm_response": """"}

# Example variables
session_id = "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
output_format = "docx"

print("\nStarting 'Get app transcript'")
print(f"Session_id: {session_id}")
print(f"Output_format: {output_format}")

# This is the main get_app_transcript API
response = client.get_app_transcript(session_id=session_id, output_format=output_format)
print("\nGet app transcript response: ", response)

{
  "response": {
    "status": "success",
    "zip_fp": "/path/to/transcript.zip"
  }
}

# Example variables
session_id = "a1b2c3d4-e5f6-7890-abcd-ef1234567890"

print("\nStarting 'Get app state'")
print(f"Session_id: {session_id}")

# This is the main get_app_state API
response = client.get_app_state(session_id=session_id)
print("\nGet app state response: ", response)

{
  "response": {
    "status": "active",
    "resources": [
      "document1.pdf"
    ],
    "chat_history_length": 5
  }
}

# Example variables
session_id = "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
updates = {"model_name":"llama-3.2-3b-instruct-ov"}

print("\nStarting 'Update app state'")
print(f"Session_id: {session_id}")
print(f"Updates: {updates}")

# This is the main update_app_state API
response = client.update_app_state(session_id=session_id, updates=updates)
print("\nUpdate app state response: ", response)

{
  "response": {
    "status": "updated",
    "session_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
}

# Example variables
session_id = "a1b2c3d4-e5f6-7890-abcd-ef1234567890"

print("\nStarting 'Stop app session'")
print(f"Session_id: {session_id}")

# This is the main stop_app_session API
response = client.stop_app_session(session_id=session_id)
print("\nStop app session response: ", response)

{
  "response": {
    "status": "stopped"
  }
}

# Example variables


print("\nStarting 'List all apps'")


# This is the main get_all_apps API
response = client.get_all_apps()
print("\nList all apps response: ", response)

{
  "app_list": [
    {
      "app_name": "contract_review",
      "version": "1.0.0"
    }
  ]
}

# Example variables
app_name = "contract_review"

print("\nStarting 'Lookup app'")
print(f"App_name: {app_name}")

# This is the main lookup_app API
response = client.lookup_app(app_name=app_name)
print("\nLookup app response: ", response)

{
  "app_details": {
    "app_name": "contract_review",
    "version": "1.0.0",
    "agents": [
      "contract_analyzer"
    ],
    "models": [
      "llama-3.2-3b-instruct-ov"
    ]
  }
}

# Example variables


print("\nStarting 'Get active app sessions'")


# This is the main get_active_app_sessions API
response = client.get_active_app_sessions()
print("\nGet active app sessions response: ", response)

{
  "response": [
    {
      "session_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
      "app_name": "contract_review",
      "status": "active"
    }
  ]
}

# Example variables
app_name = "contract_review"

print("\nStarting 'Download app'")
print(f"App_name: {app_name}")

# This is the main download_app API
response = client.download_app(app_name=app_name)
print("\nDownload app response: ", response)

{
  "response": {
    "status": "success",
    "zip_fp": "/path/to/contract_review.zip"
  }
}

# Example variables
app_zip = "contract_review.zip"

print("\nStarting 'Install app'")
print(f"App_zip: {app_zip}")

# This is the main install_app API
response = client.install_app(app_zip=app_zip)
print("\nInstall app response: ", response)

{
  "app_details": {
    "app_name": "contract_review",
    "status": "installed"
  }
}