> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://mezmo.ferndocs.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://mezmo.ferndocs.com/_mcp/server.

# Use AI to generate Regular Expressions

POST https://api.mezmo.com/v3/pipeline/ai/expression
Content-Type: application/json

Generates one or more regular expression that will parse the given log samples

Reference: https://mezmo.ferndocs.com/api-reference/pipeline/experimental/use-ai-to-generate-regular-expressions

## Authentication

- `Authorization` header (required) (prefixed with ` Token  `) — Header authentication of the form `Token <token>`

## Request

### Body (application/json)

This endpoint expects an object.

- `samples` (list of string, required) — At least 1 line to pass to the AI model for pattern generation. If the lines are not all from the same application, it will generate an expression for each identified app. It accepts a maximum of 5 lines.

## Response

### 200

Default Response

## Examples

**Request**

```json
{
  "samples": [
    "2024-06-01T12:34:56Z INFO payment-service Request processed successfully in 123ms from logs.acme-corp.io",
    "2024-06-01T12:35:01Z ERROR auth-gateway Failed login attempt for user 'jdoe' from telemetry.acme-corp.io",
    "2024-06-01T12:35:05Z WARN order-processor Order #12345 delayed due to inventory shortage at logs.acme-corp.io"
  ]
}
```

**Response**

```json
{}
```

**SDK Code**

```python
import requests

url = "https://api.mezmo.com/v3/pipeline/ai/expression"

payload = { "samples": ["2024-06-01T12:34:56Z INFO payment-service Request processed successfully in 123ms from logs.acme-corp.io", "2024-06-01T12:35:01Z ERROR auth-gateway Failed login attempt for user 'jdoe' from telemetry.acme-corp.io", "2024-06-01T12:35:05Z WARN order-processor Order #12345 delayed due to inventory shortage at logs.acme-corp.io"] }
headers = {
    "Authorization": "Token <pipeline-service-key>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript
const url = 'https://api.mezmo.com/v3/pipeline/ai/expression';
const options = {
  method: 'POST',
  headers: {
    Authorization: 'Token <pipeline-service-key>',
    'Content-Type': 'application/json'
  },
  body: '{"samples":["2024-06-01T12:34:56Z INFO payment-service Request processed successfully in 123ms from logs.acme-corp.io","2024-06-01T12:35:01Z ERROR auth-gateway Failed login attempt for user \'jdoe\' from telemetry.acme-corp.io","2024-06-01T12:35:05Z WARN order-processor Order #12345 delayed due to inventory shortage at logs.acme-corp.io"]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.mezmo.com/v3/pipeline/ai/expression"

	payload := strings.NewReader("{\n  \"samples\": [\n    \"2024-06-01T12:34:56Z INFO payment-service Request processed successfully in 123ms from logs.acme-corp.io\",\n    \"2024-06-01T12:35:01Z ERROR auth-gateway Failed login attempt for user 'jdoe' from telemetry.acme-corp.io\",\n    \"2024-06-01T12:35:05Z WARN order-processor Order #12345 delayed due to inventory shortage at logs.acme-corp.io\"\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Token <pipeline-service-key>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.mezmo.com/v3/pipeline/ai/expression")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Token <pipeline-service-key>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"samples\": [\n    \"2024-06-01T12:34:56Z INFO payment-service Request processed successfully in 123ms from logs.acme-corp.io\",\n    \"2024-06-01T12:35:01Z ERROR auth-gateway Failed login attempt for user 'jdoe' from telemetry.acme-corp.io\",\n    \"2024-06-01T12:35:05Z WARN order-processor Order #12345 delayed due to inventory shortage at logs.acme-corp.io\"\n  ]\n}"

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.mezmo.com/v3/pipeline/ai/expression")
  .header("Authorization", "Token <pipeline-service-key>")
  .header("Content-Type", "application/json")
  .body("{\n  \"samples\": [\n    \"2024-06-01T12:34:56Z INFO payment-service Request processed successfully in 123ms from logs.acme-corp.io\",\n    \"2024-06-01T12:35:01Z ERROR auth-gateway Failed login attempt for user 'jdoe' from telemetry.acme-corp.io\",\n    \"2024-06-01T12:35:05Z WARN order-processor Order #12345 delayed due to inventory shortage at logs.acme-corp.io\"\n  ]\n}")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.mezmo.com/v3/pipeline/ai/expression', [
  'body' => '{
  "samples": [
    "2024-06-01T12:34:56Z INFO payment-service Request processed successfully in 123ms from logs.acme-corp.io",
    "2024-06-01T12:35:01Z ERROR auth-gateway Failed login attempt for user \'jdoe\' from telemetry.acme-corp.io",
    "2024-06-01T12:35:05Z WARN order-processor Order #12345 delayed due to inventory shortage at logs.acme-corp.io"
  ]
}',
  'headers' => [
    'Authorization' => 'Token <pipeline-service-key>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://api.mezmo.com/v3/pipeline/ai/expression");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Token <pipeline-service-key>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"samples\": [\n    \"2024-06-01T12:34:56Z INFO payment-service Request processed successfully in 123ms from logs.acme-corp.io\",\n    \"2024-06-01T12:35:01Z ERROR auth-gateway Failed login attempt for user 'jdoe' from telemetry.acme-corp.io\",\n    \"2024-06-01T12:35:05Z WARN order-processor Order #12345 delayed due to inventory shortage at logs.acme-corp.io\"\n  ]\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "Token <pipeline-service-key>",
  "Content-Type": "application/json"
]
let parameters = ["samples": ["2024-06-01T12:34:56Z INFO payment-service Request processed successfully in 123ms from logs.acme-corp.io", "2024-06-01T12:35:01Z ERROR auth-gateway Failed login attempt for user 'jdoe' from telemetry.acme-corp.io", "2024-06-01T12:35:05Z WARN order-processor Order #12345 delayed due to inventory shortage at logs.acme-corp.io"]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.mezmo.com/v3/pipeline/ai/expression")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```