The Seekr Python Library is the official Python client for SeekrFlow's API platform, providing a convenient way for interacting with the REST APIs and enables easy integrations with Python 3.9+ applications with easy to use synchronous and asynchronous clients.

Installation

To install Seekr Python Library from PyPi, simply run:

pip install --upgrade seekrai

Setting up API Key

🚧 You will need to create an account with Seekr.com to obtain a SeekrFlow API Key.

Setting environment variable

export SEEKR_API_KEY=xxxxx

Using the client

from seekrai import SeekrFlow

with SeekrFlow(api_key="xxxxx") as client:
    response = client.models.list()
    print(response.data)

Client lifecycle and connection reuse

SeekrFlow and AsyncSeekrFlow reuse an internal HTTP client per SDK client instance.

Recommended usage:

Create one SDK client per app scope or per cached user scope (not per request).
Reuse that SDK client for all calls in that scope.
Close the SDK client on shutdown/eviction (close() or aclose()), or use context managers (with / async with).

If you already manage your own httpx.Client / httpx.AsyncClient or need custom pool settings, etc, inject it via http_client= or async_http_client= and keep lifecycle ownership in your app.

import httpx
from seekrai import SeekrFlow

shared_http_client = httpx.Client(
    http2=True,
    limits=httpx.Limits(max_connections=200, max_keepalive_connections=100),
)
try:
    client = SeekrFlow(api_key="xxxxx", http_client=shared_http_client)
    # ... reuse client across calls
finally:
    shared_http_client.close()

Per-user SDK cache (recommended pattern)

If your app caches one SDK client per user, use a shared HTTP transport for all cached SDK instances. This avoids one connection pool per user and keeps socket/FD usage bounded by one global pool.

import httpx
from cachetools import TTLCache
from seekrai import SeekrFlow

shared_http_client = httpx.Client(
    http2=True,
    limits=httpx.Limits(max_connections=300, max_keepalive_connections=100),
)
sdk_cache: TTLCache[str, SeekrFlow] = TTLCache(maxsize=5000, ttl=900)


def get_user_client(user_id: str, api_key: str) -> SeekrFlow:
    client = sdk_cache.get(user_id)
    if client is None:
        client = SeekrFlow(api_key=api_key, http_client=shared_http_client)
        sdk_cache[user_id] = client
    return client


def shutdown() -> None:
    # SDK clients do not own injected transport.
    shared_http_client.close()

Apply the same pattern for async apps with one shared httpx.AsyncClient injected into cached AsyncSeekrFlow instances, and close it once during app shutdown.

RBAC Team Routing

Every API key currently resolves to a personal team. We do not currently have application-level or shared team-level API keys.

The SDK can send the RBAC context header x-team-id when provided. This header does not grant access by itself.

Authorization is enforced server-side using the authenticated identity (API key/JWT). A request is only allowed if that identity has access to the requested team. If no team context is provided, the backend defaults to the personal team resolved from authentication.

You can set team context in either of these ways:

Set SEEKR_TEAM_ID and let the SDK populate x-team-id automatically.
Pass supplied_headers={"x-team-id": "..."} explicitly.

If both are provided, supplied_headers["x-team-id"] takes precedence.

import os
from seekrai import SeekrFlow

with SeekrFlow(api_key=os.environ.get("SEEKR_API_KEY")) as client:
    response = client.models.list()
    print(response.data)

import os
import asyncio
from seekrai import AsyncSeekrFlow

async def run():
    async with AsyncSeekrFlow(
        api_key=os.environ.get("SEEKR_API_KEY"),
        supplied_headers={"x-team-id": os.environ.get("SEEKR_TEAM_ID")},
    ) as async_client:
        response = await async_client.models.list()
        print(response.data)

asyncio.run(run())

Usage – Python Client

Chat Completions

import os
from seekrai import SeekrFlow

with SeekrFlow(api_key=os.environ.get("SEEKR_API_KEY")) as client:
    response = client.chat.completions.create(
        model="meta-llama/Llama-3.1-8B-Instruct",
        messages=[{"role": "user", "content": "tell me about new york"}],
    )

print(response.choices[0].message.content)

Streaming

import os
from seekrai import SeekrFlow

with SeekrFlow(api_key=os.environ.get("SEEKR_API_KEY")) as client:
    stream = client.chat.completions.create(
        model="meta-llama/Llama-3.1-8B-Instruct",
        messages=[{"role": "user", "content": "tell me about new york"}],
        stream=True,
    )

    for chunk in stream:
        print(chunk.choices[0].delta.content or "", end="", flush=True)

Async usage

import os, asyncio
from seekrai import AsyncSeekrFlow

messages = [
    "What are the top things to do in San Francisco?",
    "What country is Paris in?",
]


async def async_chat_completion(messages):
    async with AsyncSeekrFlow(api_key=os.environ.get("SEEKR_API_KEY")) as async_client:
        tasks = [
            async_client.chat.completions.create(
                model="meta-llama/Llama-3.1-8B-Instruct",
                messages=[{"role": "user", "content": message}],
            )
            for message in messages
        ]
        responses = await asyncio.gather(*tasks)

        for response in responses:
            print(response.choices[0].message.content)


asyncio.run(async_chat_completion(messages))

Files

The files API is used for fine-tuning and allows developers to upload data to fine-tune on. It also has several methods to list all files, retrieve files, and delete files

import os
from seekrai import SeekrFlow

with SeekrFlow(api_key=os.environ.get("SEEKR_API_KEY")) as client:
    client.files.upload(file="somedata.parquet")  # uploads a file
    client.files.list()  # lists all uploaded files
    client.files.delete(id="file-d0d318cb-b7d9-493a-bd70-1cfe089d3815")  # deletes a file

Fine-tunes

The finetune API is used for fine-tuning and allows developers to create finetuning jobs. It also has several methods to list all jobs, retrieve statuses and get checkpoints.

import os
from seekrai import SeekrFlow

with SeekrFlow(api_key=os.environ.get("SEEKR_API_KEY")) as client:
    client.fine_tuning.create(
        training_file='file-d0d318cb-b7d9-493a-bd70-1cfe089d3815',
        model='meta-llama/Llama-3.1-8B-Instruct',
        n_epochs=3,
        n_checkpoints=1,
        batch_size=4,
        learning_rate=1e-5,
        suffix='my-demo-finetune',
    )
    client.fine_tuning.list()  # lists all fine-tuned jobs
    client.fine_tuning.retrieve(id="ft-c66a5c18-1d6d-43c9-94bd-32d756425b4b")  # retrieves information on finetune event

Metadata

Release files for seekrai 0.35.1

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for seekrai 0.35.1
File	Size	Uploaded	Provenance
seekrai-0.35.1.tar.gz	1.6 MB	Oct 22, 2026	Without provenance	Details

Built distribution (wheel)

Table of built distributions (wheels) for seekrai 0.35.1
File	Interpreter	ABI	Platform	Reset
seekrai-0.35.1-py3-none-any.whl 107.8 kB Oct 22, 2026 Without provenance	Python 3	none	any	Details

Total release size: 1.7 MB

Release files / seekrai-0.35.1.tar.gz

Download URL	seekrai-0.35.1.tar.gz
Size	1.6 MB
Tags	Source
SHA-256 checksum How to use checksums	`382bdeb0a9a32b4b3fac59bbccca94fc130303231e10385b3fb6e4f923b6588f`
BLAKE2b-256 checksum How to use checksums	`2cc02ab50906c8a3a1b402e2a6dea569ceb1d1848744cb53d85d4275b3ef22f3`
Upload date	Oct 22, 2026
Uploaded using Trusted Publishing? What is trusted publishing?	No
Uploaded via	`uv/0.13.5 {"installer":{"name":"uv","version":"0.13.5","subcommand":["publish"]},"python":null,"implementation":{"name":null,"version":null},"distro":{"name":"Chainguard","version":"20230214","id":null,"libc":null},"system":{"name":null,"release":null},"cpu":null,"openssl_version":null,"setuptools_version":null,"rustc_version":null,"ci":true}`

Release files / seekrai-0.35.1-py3-none-any.whl

Download URL	seekrai-0.35.1-py3-none-any.whl
Size	107.8 kB
Tags	Python 3
SHA-256 checksum How to use checksums	`2301f7ad110572903400f71be00f6bbce94d64f4b1a70fcb71c743d256fa7fff`
BLAKE2b-256 checksum How to use checksums	`da6620fdf3d6fd063d2d168a4e721e8a658ba83e1cd8406d126ad0787abc6384`
Upload date	Oct 22, 2026
Uploaded using Trusted Publishing? What is trusted publishing?	No
Uploaded via	`uv/0.13.5 {"installer":{"name":"uv","version":"0.13.5","subcommand":["publish"]},"python":null,"implementation":{"name":null,"version":null},"distro":{"name":"Chainguard","version":"20230214","id":null,"libc":null},"system":{"name":null,"release":null},"cpu":null,"openssl_version":null,"setuptools_version":null,"rustc_version":null,"ci":true}`

Security for seekrai 0.35.1

Report project as malware

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

No provenance found

None of the files in this release were uploaded with provenance metadata.

A note on package security

PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.

To learn more about protecting yourself from malicious actors, visit our package security documentation.