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

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, api_key=api_key)
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
api_key = "your-api-key"  # Optional

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, api_key=api_key)
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"
api_key = "your-api-key"  # Optional

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, api_key=api_key)
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."
api_key = "your-api-key"  # Optional

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

# This is the main sentiment API
response = client.sentiment(context=context, api_key=api_key)
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"]
api_key = "your-api-key"  # Optional

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, api_key=api_key)
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"
api_key = "your-api-key"  # Optional

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, api_key=api_key)
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"
api_key = "your-api-key"  # Optional

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, api_key=api_key)
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"]
api_key = "your-api-key"  # Optional

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, api_key=api_key)
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"
api_key = "your-api-key"  # Optional

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, api_key=api_key)
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"
api_key = "your-api-key"  # Optional

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, api_key=api_key)
print("\nGenerate embeddings response: ", response)

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

# Example variables
trusted_key = "your-trusted-key"  # Optional

print("\nStarting 'List models'")


# This is the main list_all_models API
response = client.list_all_models(trusted_key=trusted_key)
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
trusted_key = "your-trusted-key"  # Optional

print("\nStarting 'System information'")


# This is the main system_info API
response = client.system_info(trusted_key=trusted_key)
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"
trusted_key = "your-trusted-key"  # Optional

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, trusted_key=trusted_key)
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"
trusted_key = "your-trusted-key"  # Optional

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, trusted_key=trusted_key)
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"
trusted_key = "your-trusted-key"  # Optional

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, trusted_key=trusted_key)
print("\nUnload model response: ", response)

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

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

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, api_key=api_key)
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"
api_key = "your-api-key"  # Optional

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, api_key=api_key)
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"
api_key = "your-api-key"  # Optional

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, api_key=api_key)
print("\nBatch document analysis response: ", response)

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

# Example variables
library_name = "contract_library"
account_id = "user123"
api_key = "your-api-key"  # Optional

print("\nStarting 'Create library'")
print(f"Library_name: {library_name}")
print(f"Account_id: {account_id}")

# This is the main create_new_library API
response = client.create_new_library(library_name=library_name, account_id=account_id, api_key=api_key)
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"]
api_key = "your-api-key"  # Optional

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, api_key=api_key)
print("\nAdd files to library response: ", response)

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

# Example variables
library_name = "contract_library"
user_query = "termination clauses"
result_count = 10
api_key = "your-api-key"  # Optional

print("\nStarting 'Query library'")
print(f"Library_name: {library_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, user_query=user_query, result_count=result_count, api_key=api_key)
print("\nQuery library response: ", response)

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

# Example variables
library_name = "contract_library"
api_key = "your-api-key"  # Optional

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

# This is the main get_library_card API
response = client.get_library_card(library_name=library_name, api_key=api_key)
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"
embedding_model = "llama-3.2-1b-instruct-ov"
api_key = "your-api-key"  # Optional

print("\nStarting 'Install embeddings'")
print(f"Library_name: {library_name}")
print(f"Embedding_model: {embedding_model}")

# This is the main install_embedding API
response = client.install_embedding(library_name=library_name, embedding_model=embedding_model, api_key=api_key)
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"
result_count = 5
api_key = "your-api-key"  # Optional

print("\nStarting 'Semantic search'")
print(f"Library_name: {library_name}")
print(f"User_query: {user_query}")
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, result_count=result_count, api_key=api_key)
print("\nSemantic search response: ", response)

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

# Example variables
library_name = "contract_library"
api_key = "your-api-key"  # Optional

print("\nStarting 'List documents'")
print(f"Library_name: {library_name}")

# This is the main get_document_list API
response = client.get_document_list(library_name=library_name, api_key=api_key)
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"
doc_id = "1"
api_key = "your-api-key"  # Optional

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

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

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

# Example variables
process_name = "contract_analyzer"
document_file = "contract.pdf"
input_list = ["analysis_type","text","comprehensive"]
api_key = "your-api-key"  # Optional

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

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

{
  "response": {
    "agent_name": "contract_analyzer",
    "status": "completed",
    "results": {
      "effective_date": "2024-01-01",
      "base_salary": "$150,000"
    },
    "execution_time": "45s"
  }
}

# Example variables
process_name = "contract_analyzer"
trusted_key = "your-trusted-key"  # Optional

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

# This is the main lookup_agent API
response = client.lookup_agent(process_name=process_name, trusted_key=trusted_key)
print("\nFind agent response: ", response)

{
  "response": {
    "process_name": "contract_analyzer",
    "available": true,
    "description": "Analyzes contracts for key terms",
    "version": "1.2.0"
  }
}

# Example variables
trusted_key = "your-trusted-key"  # Optional

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


# This is the main get_all_agents API
response = client.get_all_agents(trusted_key=trusted_key)
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
trusted_key = "your-trusted-key"  # Optional

print("\nStarting 'Health check'")


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

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

# Example variables
trusted_key = "your-trusted-key"  # Optional

print("\nStarting 'Stop server'")


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

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

# Example variables
trusted_key = "your-trusted-key"  # Optional

print("\nStarting 'API catalog'")


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

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