Single-Turn Endpoints

Configure request and response mappings for endpoints that handle one exchange at a time.

Request Body Templates

Request body templates define how Rhesis transforms its platform-managed variables into the JSON structure your API expects. Templates use Jinja2 syntax for dynamic values.

Basic Template

Place the input variable wherever your API expects the user query:

{
  "prompt": "{{ input }}",
  "max_tokens": 500
}

Nested Structures

For APIs that use nested message formats, embed input within the appropriate structure:

{
  "model": "gpt-4",
  "messages": [
    {
      "role": "user",
      "content": "{{ input }}"
    }
  ],
  "temperature": 0.7
}

The tojson Filter

Use the tojson filter when a variable might be null or when you need proper JSON serialization. This is especially useful for optional fields:

{
"query": "{{ input }}",
"conversation_id": {{ conversation_id | tojson }},
"metadata": {{ metadata | tojson }}
}

The tojson filter ensures values are properly formatted as JSON:

• Python None becomes JSON null
• Strings are properly quoted
• Objects and arrays are serialized correctly

Custom Static Fields

You can include any static values alongside platform variables. These are sent as-is with every request:

{
  "model": "claude-3-sonnet",
  "prompt": "{{ input }}",
  "temperature": 0.3,
  "max_tokens": 1024,
  "stream": false
}

Response Mappings

Response mappings tell Rhesis how to extract platform-managed variables from your API’s response. You can use JSONPath expressions, Jinja2 templates, or a combination of both.

JSONPath Expressions

JSONPath is the simplest approach. Expressions starting with $ are evaluated as JSONPath against the response body:

{
  "output": "$.choices[0].message.content",
  "model_used": "$.model",
  "tokens": "$.usage.total_tokens"
}

Common JSONPath patterns:

Jinja2 Templates with jsonpath()

For conditional logic or fallback values, use Jinja2 templates with the jsonpath() function:

{
  "output": "{{ jsonpath('$.text_response') or jsonpath('$.result.content') }}",
  "conversation_id": "$.conversation_id"
}

The first value evaluates as a Jinja2 template and returns the first non-empty field. Pure JSONPath expressions (starting with $) work without any wrapping.

Mixing Approaches

You can mix JSONPath and Jinja2 in the same response mapping. Each field is evaluated independently:

{
  "output": "$.response.text",
  "context": "{{ jsonpath('$.sources') or jsonpath('$.references') }}",
  "metadata": "$.usage"
}

Platform-Managed Fields

Rhesis actively uses certain mapped response fields for evaluation and tracking. Other fields are stored but not actively used by the platform.

Actively used fields:

• output: The main response text, used for metric evaluation
• context: Additional context, used by context-dependent metrics
• Conversation tracking fields (conversation_id, session_id, etc.): Used for multi-turn conversation management

Stored fields:

• metadata: Stored with the test result for reference
• tool_calls: Stored with the test result for reference
• Any custom fields you define in the response mapping

Testing Your Endpoint

Before running full test suites, verify your endpoint configuration works correctly.

1. Navigate to the Test Connection tab on the endpoint details page
2. Enter sample input data in the text field
3. Click Test Endpoint
4. Review the response to ensure it returns expected data

The test connection sends a single request using your configured template and displays the raw API response alongside the mapped result. This helps you verify that your JSONPath expressions and Jinja2 templates extract the correct values.

Example: Complete REST Endpoint

Here is a complete configuration for a typical REST endpoint calling an LLM API.

Request headers:

{
  "Authorization": "Bearer {{ auth_token }}",
  "Content-Type": "application/json"
}

The auth_token placeholder is automatically replaced with the token configured in the endpoint settings. See the Endpoints Overview for details.

Request body template:

{
  "model": "gpt-4",
  "messages": [
    {
      "role": "user",
      "content": "{{ input }}"
    }
  ],
  "temperature": 0.7,
  "max_tokens": 1024
}

Response mapping:

{
  "output": "$.choices[0].message.content",
  "metadata": "$.usage"
}

With this configuration, when Rhesis sends a test prompt like “What is machine learning?”, it formats the request, sends it to your API, extracts the response text from choices[0].message.content, and evaluates it against your configured metrics.