Praxos AI

https://docs.praxos.ai/
Admin
Praxos AI is a platform or service for artificial intelligence applications and solutions.
Tokens:21,907
Snippets:88
Trust Score:6.2
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install Praxos Python SDK

Source: https://docs.praxos.ai/index

Installs the latest version of the Praxos Python SDK using pip. Ensure you have Python 3.8 or higher.

```shell
pip install -U praxos-python
```

--------------------------------

### Initialize Praxos Client and Environment

Source: https://docs.praxos.ai/index

Initializes the Praxos client using the API key and validates it. It also demonstrates creating a new environment or retrieving an existing one.

```python
from praxos_python import SyncClient

# Initialize the client with your API key
client = SyncClient(api_key=API_KEY)

# Validate your API key
try:
    is_valid = client.validate_api_key()
    print(f"API key is valid: {is_valid}")
except Exception as e:
    print(f"API key validation failed: {e}")

# Create a new environment or get an existing one
env = client.create_environment(name="my-quickstart-environment")

# Alternative: Get an existing environment
# env = client.get_environment(name="my-quickstart-environment")
```

--------------------------------

### Configure Praxos API Key

Source: https://docs.praxos.ai/index

Sets the Praxos API key for authentication. Replace the placeholder with your actual API key, which starts with 'prx_'.

```python
# Replace with your Praxos API key
API_KEY = "prx_your_api_key_here"
```

--------------------------------

### Install Praxos Python SDK

Source: https://docs.praxos.ai/SDK/client

Installs the latest version of the Praxos Python SDK using pip. This is the primary method for getting the SDK into your project.

```Python
pip install -U praxos-python
```

--------------------------------

### Legacy Context Retrieval

Source: https://docs.praxos.ai/index

Provides an example of the legacy method for simple context retrieval using the get_context function, demonstrating how to retrieve a sentence and its relevance score.

```Python
# Simple context query  
context = env.get_context("what are the sales targets?")
print(f"Context: {context.sentence}")
print(f"Relevance Score: {context.score}")
```

--------------------------------

### Install Praxos Python SDK from Source

Source: https://docs.praxos.ai/SDK/client

Installs the Praxos Python SDK from its source code repository using Git and pip. This is useful for development or when needing the latest unreleased features.

```Python
git clone https://github.com/praxos/praxos-python
cd praxos-python
pip install -e .
```

--------------------------------

### Intelligent Search Queries

Source: https://docs.praxos.ai/index

Demonstrates how to use the intelligent_search function to ask sales targets, analytical, and temporal questions. The AI automatically understands query intent, identifies data types, selects search strategies, and performs calculations.

```Python
results = env.intelligent_search("What are our Q4 sales targets and current progress?")
results = env.intelligent_search("What's the average customer revenue by industry?")
results = env.intelligent_search("Show me enterprise customers with revenue above $200k")
```

--------------------------------

### Migrate from Traditional Search to Intelligent Search

Source: https://docs.praxos.ai/SDK/intelligent-search

Compares traditional search methods with Praxos AI's intelligent search. The 'Before' example shows multiple manual steps for data retrieval and analysis, while the 'After' example demonstrates a single, AI-powered query that achieves the same result more efficiently.

```Python
# Multiple manual steps required
results = environment.search(
    query="transaction data",
    search_modality="node_vec",
    node_type="FinancialTransaction",
    temporal_filter={"timepoint_type": "Month", "time_period": "November"},
    include_graph_context=True
)

# Manual analysis
max_amount = 0
for result in results:
    amount = extract_amount_from_result(result)  # Custom parsing
    if amount > max_amount:
        max_amount = amount
```

```Python
# Single AI-powered query
results = environment.intelligent_search(
    "Find the highest transaction amount in November"
)

# Automatic analysis included
max_transaction = results["toolset_analysis"][0]["max_value"]
```

--------------------------------

### Specific Temporal Context Example

Source: https://docs.praxos.ai/SDK/intelligent-search

A best practice example demonstrating how to include specific temporal context (e.g., a quarter) in a query for revenue by product category.

```Python
# ✅ Good: Specific temporal context
results = environment.intelligent_search("Q4 revenue by product category")
```

--------------------------------

### Extract Structured Information

Source: https://docs.praxos.ai/index

Shows how to extract specific data types like customer entities and currency amounts using extract_items and extract_literals. It assumes a 'Customer' schema and 'CurrencyAmountType' are defined in the ontology.

```Python
# Extract customer entities
customers = env.extract_items(
    schema="Customer",  # Assumes you have a Customer schema in your ontology
    top_k=50
)

# Extract revenue amounts
revenue_data = env.extract_literals(
    literal_type="CurrencyAmountType",
    mode="full_entities",
    top_k=100
)

print(f"Found {len(customers)} customers and {len(revenue_data['items'])} revenue records")
```

--------------------------------

### Add Business Data Source

Source: https://docs.praxos.ai/index

Adds structured business data, such as customer information and sales targets, as a data source to the Praxos knowledge graph. The data is provided as a Python dictionary.

```python
# Sample business data
business_data = {
    "customers": [
        {"name": "TechCorp Inc", "tier": "enterprise", "revenue": 250000, "industry": "Technology"},
        {"name": "Global Manufacturing", "tier": "premium", "revenue": 180000, "industry": "Manufacturing"},
        {"name": "StartupXYZ", "tier": "basic", "revenue": 25000, "industry": "Software"}
    ],
    "quarterly_targets": {
        "Q4_2023": {"target": 2500000, "current": 1800000, "forecast": 2200000}
    }
}

data_source = env.add_business_data(
    data=business_data,
    name="Customer and Sales Data",
    description="Q4 customer information and sales targets"
)
```

--------------------------------

### Natural Language Query Example

Source: https://docs.praxos.ai/SDK/intelligent-search

A best practice example showing a natural language query to find the highest value customers within a specific year.

```Python
# ✅ Good: Natural language queries
results = environment.intelligent_search("Who are our highest value customers this year?")
```

--------------------------------

### Praxos API Authentication Header

Source: https://docs.praxos.ai/api-reference/authentication

This snippet demonstrates the required HTTP header for authenticating requests to the Praxos API using an API key.

```HTTP
api-key: your-api-key-here
```

--------------------------------

### Praxos AI Intelligent Search Examples

Source: https://docs.praxos.ai/environment

Demonstrates how to use the Praxos AI Intelligent Search within an environment for natural language queries, automatic analytical operations, and graph-aware relationship queries.

```Python
from praxos_python import SyncClient

client = SyncClient(api_key="prx_your_api_key_here")
env = client.get_environment(name="financial_analysis")

# Natural language queries with AI analysis
results = env.intelligent_search("What are the highest risk transactions this quarter?")

# Automatic analytical operations  
results = env.intelligent_search("Calculate average deal size by customer tier")

# Graph-aware relationship queries
results = env.intelligent_search("Find all entities connected to suspicious accounts")
```

--------------------------------

### Get All Environments via cURL

Source: https://docs.praxos.ai/api-reference/endpoint/environment/get-environment

This snippet demonstrates how to retrieve a list of all environments using a cURL command. It requires an API key for authentication and targets the /environment endpoint.

```cURL
curl --request GET \
  --url https://api.praxos.ai/environment \
  --header 'API-key: <api-key>'
```

--------------------------------

### AI Query Intent Classification Examples

Source: https://docs.praxos.ai/SDK/intelligent-search

Provides examples of how the AI classifies query intent, such as `find_entities`, `extract_literals`, `temporal_query`, `analytical_query`, and `relationship_query`. It demonstrates how different natural language queries map to these intents.

```Python
# Different intent examples
results = environment.intelligent_search("Who are our premium customers?")         # find_entities
results = environment.intelligent_search("What's the average deal size?")          # analytical_query  
results = environment.intelligent_search("Show me transactions in December")       # temporal_query
results = environment.intelligent_search("Find connections between John and Mary") # relationship_query


```

--------------------------------

### Add Conversation Data Source

Source: https://docs.praxos.ai/index

Adds a conversation as a data source to the Praxos knowledge graph. It defines messages with roles and content, and provides a name and description for the source.

```python
from praxos_python.types import Message

# Create conversation messages
messages = [
    Message(role="user", content="What are our Q4 sales targets for enterprise clients?"),
    Message(role="assistant", content="Q4 targets are $2.5M with focus on Fortune 500 companies."),
    Message(role="user", content="What about our current pipeline?"),
    Message(role="assistant", content="Current pipeline shows $1.8M in qualified opportunities.")
]

conversation_source = env.add_conversation(
    messages=messages,
    name="Sales Planning Discussion",
    description="Q4 sales targets and pipeline review"
)
```

--------------------------------

### Perform Simple Intelligent Search

Source: https://docs.praxos.ai/SDK/intelligent-search

Demonstrates how to perform a basic intelligent search using the Praxos Python client. It shows how to initialize the client, get an environment, execute a search query, and process the structured results and AI analysis insights.

```Python
from praxos_python import SyncClient

client = SyncClient(api_key="prx_your_api_key_here")
environment = client.get_environment(name="financial_data")

# AI automatically handles query analysis and strategy selection
results = environment.intelligent_search(
    query="Find highest transaction amounts in November 2023"
)

# Rich structured results
for hit in results["hits"]:
    print(f"Score: {hit['score']}")
    print(f"Content: {hit['sentence']}")
    print(f"Type: {hit.get('type', 'Unknown')}")

# AI analysis insights
analysis = results["intelligent_analysis"]
print(f"Query Intent: {analysis.get('intent', 'unknown')}")
print(f"Strategies Used: {analysis['strategies_used']}")

```

--------------------------------

### Perform Intelligent Search

Source: https://docs.praxos.ai/index

Uses Praxos's Intelligent Search to query indexed data with natural language. It retrieves search results, including scores and content, and provides AI analysis insights.

```python
# Ask natural language questions about your data
results = env.intelligent_search("What are our highest revenue customers?")

print("=== Search Results ===")
for hit in results["hits"]:
    print(f"Score: {hit['score']:.2f}")
    print(f"Content: {hit['sentence']}")
    print("---")

# Access AI analysis insights
analysis = results["intelligent_analysis"]
print(f"\n=== AI Analysis ===")
print(f"Query Intent: {analysis.get('intent', 'unknown')}")
print(f"Strategies Used: {analysis['strategies_used']}")

# Check for automatic analytical operations
if "toolset_analysis" in results:
    print(f"\n=== Analytical Results ===")
    for operation in results["toolset_analysis"]:
        if operation['operation'] == 'find_maximum':
            print(f"Highest Revenue: ${operation['max_value']:,.2f}")
            print(f"Customer: {operation['max_item']}")
```

--------------------------------

### Basic Search Response Example (JSON)

Source: https://docs.praxos.ai/api-reference/endpoint/search

A simplified JSON structure representing a successful search response, containing a list of 'hits' with scores and associated data.

```JSON
{
  "hits": [
    {
      "score": 123,
      "data": {},
      "sentence": "<string>"
    }
  ]
}
```

--------------------------------

### Integrate Graph Context

Source: https://docs.praxos.ai/SDK/intelligent-search

Demonstrates how to include and access graph context in intelligent search results to leverage relationships between entities. This example retrieves business partners and their recent projects, then prints details from the graph context.

```Python
results = environment.intelligent_search(
    query="business partners and their recent projects",
    include_graph_context=True,
    max_results=30
)

# Access graph context
for hit in results["hits"]:
    if "graph_context" in hit:
        print(f"Node Type: {hit['graph_context'].get('node_type')}")
        print(f"Relationships: {hit['graph_context'].get('relationships', [])}")
        print(f"Connected Entities: {hit['graph_context'].get('connected_entities', [])}")
```

--------------------------------

### Apply Anchor Constraints

Source: https://docs.praxos.ai/SDK/intelligent-search

Illustrates how to use anchor constraints (KnownAnchor and TemporalAnchor) with intelligent search to perform precise filtering. This example searches for financial transactions with high amounts, constrained by a specific person and year.

```Python
from praxos_python.types import KnownAnchor, TemporalAnchor

# Complex anchored search
results = environment.intelligent_search(
    query="financial transactions with high amounts",
    anchors=[
        KnownAnchor(type="Person", value="John Smith", kind="entity"),
        TemporalAnchor(type="YearNumberType", value="2023")
    ],
    max_hops=2
)

# The AI will:
# 1. Identify "financial transactions" as target entities  
# 2. Extract "high amounts" as analytical intent
# 3. Apply anchor constraints (John Smith + 2023)
# 4. Execute find_maximum operation on results
```

--------------------------------

### Detecting and Unifying Data Types

Source: https://docs.praxos.ai/SDK/intelligent-search

Explains how the system identifies and unifies relevant entity and literal types from the user's ontology. It shows an example of a search query and how to access the detected relevant types from the AI analysis.

```Python
results = environment.intelligent_search("financial transactions with high amounts")

# AI identifies relevant types from your data
analysis = results["intelligent_analysis"]
print(f"Detected Types: {analysis.get('relevant_types', [])}")
# Example output: ['FinancialTransaction', 'CurrencyAmountType', 'MonetaryValue']


```

--------------------------------

### Customer Support Conversation Pattern with Praxos Message in Python

Source: https://docs.praxos.ai/SDK/data-types

Provides an example of structuring a customer support conversation using the `Message` class, defining roles like 'customer' and 'agent' to represent the dialogue flow.

```Python
support_messages = [
    Message(role="customer", content="I'm having trouble accessing my account"),
    Message(role="agent", content="I'd be happy to help. Can you provide your account email?"),
    Message(role="customer", content="It's john.doe@example.com"),
    Message(role="agent", content="I see the issue. Your account was temporarily locked. I've unlocked it now."),
    Message(role="customer", content="Thank you! I can access it now.")
]
```

--------------------------------

### Trigger Automatic Analytics

Source: https://docs.praxos.ai/SDK/intelligent-search

Shows examples of queries that automatically trigger analytical operations within the intelligent search. It also demonstrates how to access and interpret the results of these operations, such as finding maximum values or calculating averages.

```Python
# Queries that trigger automatic analytics
results = environment.intelligent_search("What's our highest revenue this quarter?")
results = environment.intelligent_search("Show me the average transaction amount")
results = environment.intelligent_search("Find the minimum order value")
results = environment.intelligent_search("Count how many customers we have")

# Access analytical results
if "toolset_analysis" in results:
    for operation in results["toolset_analysis"]:
        print(f"Operation: {operation['operation']}")
        
        if operation['operation'] == 'find_maximum':
            print(f"Highest Value: ${operation['max_value']:,.2f}")
            print(f"Associated Item: {operation['max_item']}")
            
        elif operation['operation'] == 'calculate_average':
            print(f"Average: ${operation['average_value']:,.2f}")
            print(f"Total Items: {operation['total_items_analyzed']}")
```

--------------------------------

### Automatic Temporal Information Extraction

Source: https://docs.praxos.ai/SDK/intelligent-search

Shows how the system automatically extracts temporal information from natural language queries. It provides examples of different query formats and demonstrates how to access the extracted temporal anchors from the search results.

```Python
# Example queries with automatic temporal detection
queries = [
    "revenue trends in Q4 2023",           # → Quarter(4) + Year(2023)
    "meetings scheduled for December",      # → Month(12)
    "transactions from last quarter",       # → Relative temporal
    "annual performance in 2022",          # → Year(2022)
    "monthly sales data for January"       # → Month(1)
]

for query in queries:
    results = environment.intelligent_search(query)
    
    # Access extracted temporal anchors
    temporal_anchors = results["intelligent_analysis"].get("temporal_anchors", [])
    print(f"Query: {query}")
    print(f"Extracted Anchors: {temporal_anchors}")


```

--------------------------------

### Praxos AI Intelligent Search Response Structure

Source: https://docs.praxos.ai/api-reference/endpoint/search

Example JSON response structure for an Intelligent Search query. It includes search results ('hits') with scores and sentences, along with detailed 'intelligent_analysis' and 'toolset_analysis' providing insights into the AI's execution.

```JSON
{
  "hits": [
    {
      "score": 0.95,
      "sentence": "High-value transaction of $15,750 processed in November 2023",
      "data": {...},
      "type": "FinancialTransaction",
      "graph_context": {...}
    }
  ],
  "intelligent_analysis": {
    "intent": "analytical_query",
    "strategies_used": ["node_vec", "analytical"],
    "temporal_anchors": [
      {"type": "MonthOfYearType", "value": "11"},
      {"type": "YearNumberType", "value": "2023"}
    ],
    "relevant_types": ["FinancialTransaction", "CurrencyAmountType"],
    "execution_time_ms": 245
  },
  "toolset_analysis": [
    {
      "operation": "find_maximum",
      "field": "amount", 
      "max_value": 15750.00,
      "max_item": "Transaction #TXN-2023-11-456",
      "total_items_analyzed": 1247
    }
  ]
}
```

--------------------------------

### Praxos AI Intelligent Search Request

Source: https://docs.praxos.ai/api-reference/endpoint/search

Example cURL request for performing an Intelligent Search on the Praxos API. This modality uses AI for query orchestration and supports natural language understanding, temporal extraction, and multi-strategy execution.

```cURL
curl -X POST "https://api.praxos.ai/search" \
  -H "api-key: prx_your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "Find highest transaction amounts in November 2023",
    "environment_id": "env-123",
    "search_modality": "intelligent",
    "max_results": 20,
    "enable_multi_strategy": true,
    "include_graph_context": true
  }'
```

--------------------------------

### Complex Intelligent Search with Multiple Strategies

Source: https://docs.praxos.ai/SDK/intelligent-search

Demonstrates a complex intelligent search query that leverages multiple underlying search strategies. This example shows how the system can combine strategies like `node_vec`, `fast`, `type_vec`, and `analytical` to handle sophisticated queries.

```Python
# Complex query using multiple strategies
results = environment.intelligent_search(
    "Find the top 5 highest revenue customers from Q4"
)


```

--------------------------------

### Praxos AI Python SDK Integration

Source: https://docs.praxos.ai/api-reference/endpoint/search

Demonstrates how to initialize the SyncClient and perform both intelligent and traditional searches using the Praxos AI Python SDK. It shows setting up the client with an API key and environment ID.

```Python
from praxos_python import SyncClient

client = SyncClient(api_key="prx_your_api_key_here")
environment = client.get_environment(id="env-123")

# Intelligent search
results = environment.intelligent_search(
    query="Find highest transaction amounts in November 2023"
)

# Traditional search  
results = environment.search(
    query="customer complaints",
    search_modality="fast",
    top_k=10
)
```

--------------------------------

### Monitor Data Source Indexing Status

Source: https://docs.praxos.ai/index

Monitors the indexing status of added data sources. It repeatedly checks the status until it's 'success' or 'failed', with a short delay between checks.

```python
import time

# Check status of both sources
sources = [conversation_source, data_source]

for source in sources:
    print(f"Checking status for: {source.name}")
    
    # Wait for indexing to complete
    while source.get_status() != "success":
        status = source.get_status()
        print(f"Status: {status}...")
        if status == "failed":
            print("Indexing failed!")
            break
        time.sleep(2)
    
    print(f"✅ {source.name} is ready!")
```

--------------------------------

### Configure Praxos SyncClient

Source: https://docs.praxos.ai/SDK/client

Demonstrates advanced configuration options for the SyncClient, including setting a custom base URL, request timeout, and global query parameters.

```Python
# Advanced client configuration
client = SyncClient(
    api_key="prx_your_api_key_here",
    base_url="https://api.praxos.ai/",
    timeout=30.0,
    params={"version": "v1"}  # Optional global parameters
)
```

--------------------------------

### Initialize Praxos SyncClient

Source: https://docs.praxos.ai/SDK/client

Initializes the Praxos SyncClient with a required API key. This client is used to interact with the Praxos API for synchronous operations.

```Python
from praxos_python import SyncClient

client = SyncClient(api_key="your-api-key")
```

--------------------------------

### Import Praxos SDK Components

Source: https://docs.praxos.ai/SDK/client

Shows essential imports from the Praxos Python SDK, including client classes, environment, source, ontology, and exception types, as well as types for message and context handling.

```Python
from praxos_python import (
    SyncClient,
    SyncEnvironment, 
    SyncSource,
    SyncOntology,
    APIError
)

# For message handling in conversations
from praxos_python.types import Message

# For search result handling
from praxos_python.models import Context
```

--------------------------------

### Create Customer Support Environment with Praxos AI

Source: https://docs.praxos.ai/environment

Illustrates creating a separate environment for customer support interactions and analyzing support patterns using the Praxos AI client.

```Python
# Separate environment for customer interactions
support_env = client.create_environment(
    name="customer_support", 
    description="Customer conversations and issue tracking"
)

# Analyze support patterns
issue_analysis = support_env.intelligent_search(
    "What are the most common customer complaints this month?"
)
```

--------------------------------

### Associate Ontologies with Environments

Source: https://docs.praxos.ai/SDK/ontology

Demonstrates how to create a Praxos AI environment and associate it with specific ontologies, either by passing SyncOntology objects or their ID strings.

```Python
# Create an environment with specific ontologies
environment = client.create_environment(
    name="customer-analysis",
    description="Environment for analyzing customer data",
    ontologies=[ontology]  # Can pass SyncOntology objects or ID strings
)

# Or use ontology IDs directly
environment = client.create_environment(
    name="customer-analysis",
    ontologies=["onto-123abc", "onto-456def"]
)

```

--------------------------------

### Create and Organize Ontologies

Source: https://docs.praxos.ai/SDK/ontology

Demonstrates how to create and organize ontologies using the Praxos AI client. It shows the creation of two ontologies, `financial-entities` and `human-resources`, with clear names, descriptions, and associated schemas.

```Python
# Good: Focused, well-organized ontology
financial_ontology = client.create_ontology(
    name="financial-entities",
    description="Core financial entities for accounting and reporting",
    schemas=[Transaction, Account, Invoice, Payment]
)

# Good: Clear separation of concerns
hr_ontology = client.create_ontology(
    name="human-resources",
    description="Employee and organizational structure entities",
    schemas=[Employee, Department, Position, Benefit]
)
```

--------------------------------

### Create Praxos Environment

Source: https://docs.praxos.ai/SDK/client

Creates a new environment within Praxos. This can be done with just a name, or with additional parameters like a description and associated ontologies.

```Python
# Create a new environment
environment = client.create_environment(name="my-environment")

# Create an environment with description and ontologies
environment = client.create_environment(
    name="my-environment",
    description="Environment for processing customer data",
    ontologies=["customer-ontology-id"]  # List of ontology IDs or SyncOntology objects
)
```

--------------------------------

### Create Praxos AI Environment

Source: https://docs.praxos.ai/api-reference/endpoint/environment/post-environment

This snippet demonstrates how to create a new environment using the Praxos AI API via a POST request. It requires an API key and a JSON payload containing the environment's name and description.

```cURL
curl --request POST \
  --url https://api.praxos.ai/environment \
  --header 'API-key: <api-key>' \
  --header 'Content-Type: application/json' \
  --data '{ \
  "name": "<string>", \
  "description": "<string>" \
}'
```

--------------------------------

### Create Financial Services Environment with Praxos AI

Source: https://docs.praxos.ai/environment

Shows how to create a dedicated environment for financial data analysis and compliance monitoring using the Praxos AI client, including querying for suspicious transactions.

```Python
# Create specialized environment for financial data
financial_env = client.create_environment(
    name="financial_compliance",
    description="Financial transactions and compliance monitoring"
)

# Query with domain-specific intelligence
suspicious_transactions = financial_env.intelligent_search(
    "Find transactions above $10k with high risk indicators"
)
```

--------------------------------

### Define Pydantic Models for Ontology

Source: https://docs.praxos.ai/SDK/client

Defines data schemas using Pydantic models, which are used to structure data within Praxos ontologies. This example shows models for Person and Organization.

```Python
from pydantic import BaseModel, Field
from typing import Optional

# Define your data schemas using Pydantic models
class Person(BaseModel):
    name: str = Field(description="Full name of the person")
    age: Optional[int] = Field(description="Age in years")
    email: Optional[str] = Field(description="Email address")

class Organization(BaseModel):
    name: str = Field(description="Organization name")
    industry: Optional[str] = Field(description="Industry sector")
    employees: Optional[int] = Field(description="Number of employees")
```

--------------------------------

### Get Multiple Context Items

Source: https://docs.praxos.ai/SDK/data-types

Retrieves multiple context items based on a query and prints their scores, sentences, and data keys. This is useful for understanding the relevance and content of retrieved information.

```Python
contexts = environment.get_context(
    query="key performance indicators",
    top_k=5
)

for i, ctx in enumerate(contexts):
    print(f"\nResult {i+1}:")
    print(f"  Score: {ctx.score:.3f}")
    print(f"  Content: {ctx.sentence}")
    print(f"  Data Keys: {list(ctx.data.keys())}")
```

--------------------------------

### Create Basic Business Entities Ontology

Source: https://docs.praxos.ai/SDK/ontology

Defines and creates a basic ontology for business entities like Person and Company using Pydantic models. It requires the `praxos_python` library and Pydantic.

```Python
from praxos_python import SyncClient
from pydantic import BaseModel, Field
from typing import Optional

client = SyncClient(api_key="your-api-key")

# Define your entity schemas
class Person(BaseModel):
    name: str = Field(description="Full name of the person")
    age: Optional[int] = Field(description="Age in years")
    email: Optional[str] = Field(description="Email address")

class Company(BaseModel):
    name: str = Field(description="Company name")
    industry: Optional[str] = Field(description="Industry sector")
    founded: Optional[int] = Field(description="Year founded")

# Create the ontology
ontology = client.create_ontology(
    name="business-entities",
    description="Core business entity definitions",
    schemas=[Person, Company]
)

print(f"Created ontology: {ontology.id}")

```

--------------------------------

### Environment Response Structure

Source: https://docs.praxos.ai/api-reference/endpoint/environment/get-environment

This JSON structure represents a successful response when retrieving environment details from the Praxos AI API. It includes fields like id, name, description, and creation timestamp.

```JSON
{
  "id": "<string>",
  "name": "<string>",
  "description": "<string>",
  "created_at": "2023-11-07T05:31:56Z"
}
```

--------------------------------

### List Sources via cURL

Source: https://docs.praxos.ai/api-reference/endpoint/sources/get-source

This snippet demonstrates how to list all sources from the Praxos AI API using a cURL command. It requires an API key for authentication and targets the /sources endpoint.

```cURL
curl --request GET \
  --url https://api.praxos.ai/sources \
  --header 'API-key: <api-key>'
```

--------------------------------

### Praxos AI Traditional Search Request

Source: https://docs.praxos.ai/api-reference/endpoint/search

Example cURL request for performing a Traditional Search (e.g., 'fast' modality) on the Praxos API. This is suitable for quick Qdrant vector searches or specific filtered lookups.

```cURL
curl -X POST "https://api.praxos.ai/search" \
  -H "api-key: prx_your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "customer complaints",
    "environment_id": "env-123", 
    "search_modality": "fast",
    "top_k": 10,
    "node_type": "schema:Review"
  }'
```

--------------------------------

### Praxos AI Invalid Search Modality Error

Source: https://docs.praxos.ai/api-reference/endpoint/search

An example of an error response from the Praxos AI system indicating an unsupported search modality. It includes the error code, a descriptive message, and details on supported modalities.

```JSON
{
  "error": {
    "code": "INVALID_SEARCH_MODALITY",
    "message": "Unsupported search modality: invalid_mode",
    "details": {
      "supported_modalities": ["intelligent", "fast", "node_vec", "vec_edge", "type_vec"]
    }
  }
}
```

--------------------------------

### Praxos AI API Source Creation Response

Source: https://docs.praxos.ai/api-reference/endpoint/sources/add-source

This JSON structure represents a successful response after creating a new source via the Praxos AI API. It includes the unique identifier, name, environment details, creation timestamp, description, and status of the newly created source.

```JSON
{
  "id": "<string>",
  "name": "<string>",
  "environment_id": "<string>",
  "created_at": "2023-11-07T05:31:56Z",
  "description": "<string>",
  "status": "<string>"
}
```

--------------------------------

### Meeting Notes Pattern with Praxos Message in Python

Source: https://docs.praxos.ai/SDK/data-types

Shows an example of structuring meeting notes using the `Message` class, assigning roles like 'moderator', 'product_manager', 'engineering_lead', and 'ceo' to represent different participants' contributions.

```Python
meeting_messages = [
    Message(role="moderator", content="Let's discuss the Q1 roadmap priorities"),
    Message(role="product_manager", content="Our top priority should be the mobile app redesign"),
    Message(role="engineering_lead", content="We need to consider the technical debt in the API layer first"),
    Message(role="ceo", content="What's the timeline and resource requirements for both initiatives?")
]
```

--------------------------------

### Praxos AI Traditional Search Response Structure

Source: https://docs.praxos.ai/api-reference/endpoint/search

Example JSON response structure for a Traditional Search query. It contains search results ('hits') with scores and sentences, along with total results count and execution time.

```JSON
{
  "hits": [
    {
      "score": 0.85,
      "data": {...},
      "sentence": "Generated description text"
    }
  ],
  "total": 150,
  "execution_time_ms": 45
}
```

--------------------------------

### Create New Source using cURL

Source: https://docs.praxos.ai/api-reference/endpoint/sources/add-source

This snippet demonstrates how to create a new source by sending a POST request to the Praxos AI API. It includes multipart/form-data for file uploads and string parameters for name and description.

```cURL
curl --request POST \
  --url https://api.praxos.ai/sources \
  --header 'Content-Type: multipart/form-data' \
  --form 'name=<string>' \
  --form 'description=<string>' \
  --form file=@example-file
```

--------------------------------

### Create Praxos Ontology

Source: https://docs.praxos.ai/SDK/client

Creates a new ontology in Praxos, defining the structure and types of data. It accepts a name, description, and a list of Pydantic schemas.

```Python
# Create an ontology with multiple schemas
ontology = client.create_ontology(
    name="business-ontology",
    description="Ontology for business entities",
    schemas=[Person, Organization]
)
```

--------------------------------

### List Ontologies via cURL

Source: https://docs.praxos.ai/api-reference/endpoint/ontology/get

This snippet demonstrates how to list all ontologies using a cURL command. It requires an API key for authentication and targets the /ontology endpoint.

```cURL
curl --request GET \
  --url https://api.praxos.ai/ontology \
  --header 'API-key: <api-key>'
```

--------------------------------

### Use Praxos SyncClient with Context Manager

Source: https://docs.praxos.ai/SDK/client

Utilizes the Praxos SyncClient with Python's `with` statement, ensuring the client is properly managed and automatically closed upon exiting the context.

```Python
with SyncClient(api_key="your-api-key") as client:
    environment = client.create_environment(name="my-environment")
    # Client will be automatically closed when exiting the context
```

--------------------------------

### Configure Intelligent Search Parameters

Source: https://docs.praxos.ai/SDK/intelligent-search

Illustrates how to use the `intelligent_search` method with various parameters to customize the search behavior. This includes setting the maximum number of results, specifying a source ID, enabling/disabling multi-strategy execution, forcing a specific strategy, including graph context, and defining anchor constraints.

```Python
results = environment.intelligent_search(
    query="premium customers with high transaction volumes",
    max_results=25,                    # Number of results (default: 20)
    source_id="source-123",            # Optional: specific source
    enable_multi_strategy=True,        # Combine strategies (default: True)
    force_strategy=None,               # Force specific strategy (optional)
    include_graph_context=True,        # Include relationship data
    anchors=[...],                     # Anchor constraints (optional)
    max_hops=2                         # Graph traversal depth
)


```

--------------------------------

### Retrieve All Ontologies

Source: https://docs.praxos.ai/SDK/ontology

Fetches and lists all ontologies associated with the Praxos AI account. This function iterates through the retrieved ontologies and prints their names and descriptions.

```Python
# List all ontologies in your account
ontologies = client.get_ontologies()

for ontology in ontologies:
    print(f"Ontology: {ontology.name} (ID: {ontology.id})")
    print(f"Description: {ontology.description}")

```

--------------------------------

### Create Advanced Project Management Ontology

Source: https://docs.praxos.ai/SDK/ontology

Defines and creates a comprehensive ontology for project management, including entities like Contact, Project, and Meeting with advanced schema definitions and validators. Requires Pydantic.

```Python
from pydantic import BaseModel, Field, validator
from typing import Optional, List
from datetime import datetime

class Contact(BaseModel):
    name: str = Field(description="Contact name")
    phone: Optional[str] = Field(description="Phone number")
    email: Optional[str] = Field(description="Email address")
    
    @validator('email')
    def validate_email(cls, v):
        if v and '@' not in v:
            raise ValueError('Invalid email format')
        return v

class Project(BaseModel):
    title: str = Field(description="Project title")
    status: str = Field(description="Project status", default="active")
    budget: Optional[float] = Field(description="Project budget in USD")
    team_size: Optional[int] = Field(description="Number of team members")
    tags: Optional[List[str]] = Field(description="Project tags")

class Meeting(BaseModel):
    title: str = Field(description="Meeting title")
    participants: Optional[List[str]] = Field(description="List of participant names")
    duration_minutes: Optional[int] = Field(description="Meeting duration in minutes")
    action_items: Optional[List[str]] = Field(description="List of action items")

# Create a comprehensive project management ontology
project_ontology = client.create_ontology(
    name="project-management",
    description="Ontology for project management entities",
    schemas=[Contact, Project, Meeting]
)

```

--------------------------------

### Create Ontology using cURL

Source: https://docs.praxos.ai/api-reference/endpoint/ontology/create

This snippet demonstrates how to create a new ontology using a POST request to the Praxos AI API. It requires an API key for authentication and a JSON payload containing the ontology's name, description, and schemas.

```cURL
curl --request POST \
  --url https://api.praxos.ai/ontology \
  --header 'API-key: <api-key>' \
  --header 'Content-Type: application/json' \
  --data '{ \
  "name": "<string>", \
  "description": "<string>", \
  "schemas": {} \
}'
```

--------------------------------

### Handle Praxos API Errors

Source: https://docs.praxos.ai/SDK/client

Demonstrates how to handle specific Praxos API errors, such as invalid API keys or general API issues, using try-except blocks.

```Python
from praxos_python.exceptions import APIError, APIKeyInvalidError

try:
    environment = client.create_environment(name="my-environment")
except APIKeyInvalidError:
    print("Invalid API key")
except APIError as e:
    print(f"API error: {e.message}")
```

--------------------------------

### Retrieve Praxos Environments

Source: https://docs.praxos.ai/SDK/client

Retrieves environments from Praxos. This includes fetching all environments, a specific environment by its ID, or by its name.

```Python
# Get all environments
environments = client.get_environments()

# Get a specific environment by ID
environment = client.get_environment(id="env-123")

# Get a specific environment by name
environment = client.get_environment(name="my-environment")
```

--------------------------------

### Create and Use Praxos Message Objects in Python

Source: https://docs.praxos.ai/SDK/data-types

Demonstrates how to create `Message` objects with different parameters, including basic creation, with a custom timestamp, and minimal required content. It also shows how to access message properties and print them.

```Python
from praxos_python.types import Message
from datetime import datetime

# Basic message creation
message = Message(
    content="Hello, how can I help you today?",
    role="assistant"
)

# Message with custom timestamp
message = Message(
    content="I need help with my account",
    role="user",
    timestamp=datetime(2023, 12, 1, 14, 30, 0)
)

# Minimal message (only content required)
message = Message(content="This is a message without role")

print(f"Message: {message.content}")
print(f"Role: {message.role}")
print(f"Timestamp: {message.timestamp}")
```
Tokens:
Raw