Python SDK

import os
from alchemyst_ai import AlchemystAI

client = AlchemystAI(
    api_key=os.environ.get("ALCHEMYST_AI_API_KEY"),  # This is the default and can be omitted
)

# Build documents array
docs_array = []

docs_array.append({
    "content": "files content",
    "metadata": {   # optional
        "filename": "file_name",
        "filetype": "pdf/txt/json",
        "groupName": ["group1", "group2"]
    }
})

# Add documents to context
response = client.v1.context.add(
    documents=docs_array,
    source="source of context data",
    context_type="resource",   # one of: resource | conversation | instruction
    scope="internal",          # one of: internal | external
    metadata={
        "fileName": "name of the file",
        "fileType": "type",
        "lastModified": "timestamp",
        "fileSize": 1234,   # number
        "groupName": ["group1", "group2"]
    }
)

from alchemyst_ai import AlchemystAI

client = AlchemystAI()

results = client.v1.context.search(
    query="your search query",
    similarity_threshold=0.8,
    minimum_similarity_threshold=0.5,
    scope="internal",   # internal | external
    metadata={          # Optional - can be None
        "fileType": "ai/conversation",
        "fileName": "chatgpt-convo-1",
        "groupName": ["project-name"]
    }
)

import os
import asyncio
from alchemyst_ai import AsyncAlchemystAI

client = AsyncAlchemystAI(
    api_key=os.environ.get("ALCHEMYST_AI_API_KEY"),  # This is the default and can be omitted
)


async def main() -> None:
    response = await client.v1.context.add(
        documents=[{"content": "files content"}],
        source="source of context data",
        context_type="resource",
        scope="internal",
    )


asyncio.run(main())

# install from PyPI
pip install alchemystai[aiohttp]

import asyncio
from alchemyst_ai import DefaultAioHttpClient
from alchemyst_ai import AsyncAlchemystAI


async def main() -> None:
    async with AsyncAlchemystAI(
        api_key="My API Key",
        http_client=DefaultAioHttpClient(),
    ) as client:
        response = await client.v1.context.add()


asyncio.run(main())

from alchemyst_ai import AlchemystAI

client = AlchemystAI()

response = client.v1.context.add(
    metadata={},
)
print(response.metadata)

import alchemyst_ai
from alchemyst_ai import AlchemystAI

client = AlchemystAI()

try:
    client.v1.context.add()
except alchemyst_ai.APIConnectionError as e:
    print("The server could not be reached")
    print(e.__cause__)  # an underlying Exception, likely raised within httpx.
except alchemyst_ai.RateLimitError as e:
    print("A 429 status code was received; we should back off a bit.")
except alchemyst_ai.APIStatusError as e:
    print("Another non-200-range status code was received")
    print(e.status_code)
    print(e.response)

from alchemyst_ai import AlchemystAI

# Configure the default for all requests:
client = AlchemystAI(
    # default is 2
    max_retries=0,
)

# Or, configure per-request:
client.with_options(max_retries=5).v1.context.add()

from alchemyst_ai import AlchemystAI

# Configure the default for all requests:
client = AlchemystAI(
    # 20 seconds (default is 1 minute)
    timeout=20.0,
)

# More granular control:
client = AlchemystAI(
    timeout=httpx.Timeout(60.0, read=5.0, write=10.0, connect=2.0),
)

# Override per-request:
client.with_options(timeout=5.0).v1.context.add()

$ export ALCHEMYST_AI_LOG=info

if response.my_field is None:
  if 'my_field' not in response.model_fields_set:
    print('Got json like {}, without a "my_field" key present at all.')
  else:
    print('Got json like {"my_field": null}.')

from alchemyst_ai import AlchemystAI

client = AlchemystAI()
response = client.v1.context.with_raw_response.add()
print(response.headers.get('X-My-Header'))

context = response.parse()  # get the object that `v1.context.add()` would have returned
print(context)

with client.v1.context.with_streaming_response.add() as response:
    print(response.headers.get("X-My-Header"))

    for line in response.iter_lines():
        print(line)

import httpx

response = client.post(
    "/foo",
    cast_to=httpx.Response,
    body={"my_param": True},
)

print(response.headers.get("x-foo"))

import httpx
from alchemyst_ai import AlchemystAI, DefaultHttpxClient

client = AlchemystAI(
    # Or use the `ALCHEMYST_AI_BASE_URL` env var
    base_url="http://my.test.server.example.com:8083",
    http_client=DefaultHttpxClient(
        proxy="http://my.test.proxy.example.com",
        transport=httpx.HTTPTransport(local_address="0.0.0.0"),
    ),
)

client.with_options(http_client=DefaultHttpxClient(...))

from alchemyst_ai import AlchemystAI

with AlchemystAI() as client:
  # make requests here
  ...

# HTTP client is now closed

import alchemyst_ai
print(alchemyst_ai.__version__)