abyss-ai-sdk 0.1.0__tar.gz

abyss_ai_sdk-0.1.0/.gitignore

@@ -0,0 +1,3 @@
+.env
+venv/
+dist/

abyss_ai_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: abyss-ai-sdk
+Version: 0.1.0
+Summary: Multi-provider AI utility with structured responses and streaming
+Project-URL: Homepage, https://github.com/Abyss-Systems/Abyss-SDK-Python
+License: MIT
+Requires-Python: >=3.9
+Requires-Dist: anthropic>=0.25.0
+Requires-Dist: groq>=0.9.0
+Requires-Dist: openai>=1.0.0
+Requires-Dist: pydantic>=2.0.0

abyss_ai_sdk-0.1.0/abyss/__init__.py

@@ -0,0 +1,7 @@
+from .client import ask, stream, embed, create_client
+from .types import AbyssConfig, AskOptions, AskResult, EmbedOptions, EmbedResult
+
+__all__ = [
+    "ask", "stream", "embed", "create_client",
+    "AbyssConfig", "AskOptions", "AskResult", "EmbedOptions", "EmbedResult",
+]

abyss_ai_sdk-0.1.0/abyss/client.py

@@ -0,0 +1,80 @@
+import json
+from .types import AbyssConfig, AskOptions, AskResult, EmbedOptions, EmbedResult
+from .providers.groq import groq_ask, groq_stream
+from .providers.openai import openai_ask, openai_stream, openai_embed
+from .providers.anthropic import anthropic_ask, anthropic_stream
+
+DEFAULT_MODELS = {
+    "groq": "llama-3.1-8b-instant",
+    "openai": "gpt-4o-mini",
+    "anthropic": "claude-sonnet-4-6",
+}
+
+def _build_system(schema_cls, base: str | None) -> str | None:
+    parts = []
+    if base:
+        parts.append(base)
+    if schema_cls:
+        parts.append("Respond ONLY with a valid JSON object. No markdown, no explanation, just raw JSON.")
+        import json
+        parts.append(f"Schema fields: {list(schema_cls.model_fields.keys())}")
+    return "\n\n".join(parts) if parts else None
+
+def _parse_structured(raw: str, schema_cls):
+    cleaned = raw.replace("```json", "").replace("```", "").strip()
+    return schema_cls.model_validate_json(cleaned)
+
+def ask(config: AbyssConfig, options: AskOptions) -> AskResult:
+    model = config.model or DEFAULT_MODELS[config.provider]
+    system = _build_system(options.schema, options.system)
+    opts = options.model_copy(update={"system": system})
+
+    def parse(raw: str):
+        if options.schema:
+            return _parse_structured(raw, options.schema)
+        return raw
+
+    match config.provider:
+        case "groq":
+            return groq_ask(config.api_key, model, opts, parse)
+        case "openai":
+            return openai_ask(config.api_key, model, opts, parse)
+        case "anthropic":
+            return anthropic_ask(config.api_key, model, opts, parse)
+        case _:
+            raise ValueError(f"Unknown provider: {config.provider}")
+
+def stream(config: AbyssConfig, options: AskOptions):
+    model = config.model or DEFAULT_MODELS[config.provider]
+
+    match config.provider:
+        case "groq":
+            yield from groq_stream(config.api_key, model, options)
+        case "openai":
+            yield from openai_stream(config.api_key, model, options)
+        case "anthropic":
+            yield from anthropic_stream(config.api_key, model, options)
+        case _:
+            raise ValueError(f"Unknown provider: {config.provider}")
+
+def embed(config: AbyssConfig, options: EmbedOptions) -> EmbedResult:
+    if config.provider != "openai":
+        raise ValueError("Embeddings only supported with provider 'openai'.")
+    return openai_embed(config.api_key, options)
+
+class AbyssClient:
+    def __init__(self, config: AbyssConfig):
+        self.config = config
+
+    def ask(self, options: AskOptions) -> AskResult:
+        return ask(self.config, options)
+
+    def stream(self, options: AskOptions):
+        yield from stream(self.config, options)
+
+    def embed(self, options: EmbedOptions) -> EmbedResult:
+        return embed(self.config, options)
+
+def create_client(provider: str, api_key: str, model: str | None = None) -> AbyssClient:
+    config = AbyssConfig(provider=provider, api_key=api_key, model=model)
+    return AbyssClient(config)

abyss_ai_sdk-0.1.0/abyss/providers/anthropic.py

@@ -0,0 +1,37 @@
+from anthropic import Anthropic
+from ..types import AskOptions, AskResult
+from typing import Callable
+
+def anthropic_ask(api_key: str, model: str, options: AskOptions, parse: Callable) -> AskResult:
+    client = Anthropic(api_key=api_key)
+
+    kwargs = dict(
+        model=model,
+        max_tokens=options.max_tokens,
+        messages=[{"role": "user", "content": options.prompt}],
+    )
+    if options.system:
+        kwargs["system"] = options.system
+    if options.temperature is not None:
+        kwargs["temperature"] = options.temperature
+
+    res = client.messages.create(**kwargs)
+    raw = next((b.text for b in res.content if b.type == "text"), "")
+
+    return AskResult(data=parse(raw), raw=raw, provider="anthropic", model=model)
+
+def anthropic_stream(api_key: str, model: str, options: AskOptions):
+    client = Anthropic(api_key=api_key)
+
+    kwargs = dict(
+        model=model,
+        max_tokens=options.max_tokens,
+        messages=[{"role": "user", "content": options.prompt}],
+        stream=True,
+    )
+    if options.system:
+        kwargs["system"] = options.system
+
+    with client.messages.stream(**kwargs) as s:
+        for text in s.text_stream:
+            yield text

abyss_ai_sdk-0.1.0/abyss/providers/groq.py

@@ -0,0 +1,43 @@
+from groq import Groq
+from ..types import AskOptions, AskResult
+from typing import Any, Callable, AsyncIterator
+
+def groq_ask(api_key: str, model: str, options: AskOptions, parse: Callable) -> AskResult:
+    client = Groq(api_key=api_key)
+
+    messages = []
+    if options.system:
+        messages.append({"role": "system", "content": options.system})
+    messages.append({"role": "user", "content": options.prompt})
+
+    res = client.chat.completions.create(
+        model=model,
+        messages=messages,
+        temperature=options.temperature,
+        max_tokens=options.max_tokens,
+    )
+
+    raw = res.choices[0].message.content or ""
+
+    return AskResult(data=parse(raw), raw=raw, provider="groq", model=model)
+
+def groq_stream(api_key: str, model: str, options: AskOptions):
+    client = Groq(api_key=api_key)
+
+    messages = []
+    if options.system:
+        messages.append({"role": "system", "content": options.system})
+    messages.append({"role": "user", "content": options.prompt})
+
+    res = client.chat.completions.create(
+        model=model,
+        messages=messages,
+        temperature=options.temperature,
+        max_tokens=options.max_tokens,
+        stream=True,
+    )
+
+    for chunk in res:
+        text = chunk.choices[0].delta.content
+        if text:
+            yield text

abyss_ai_sdk-0.1.0/abyss/providers/openai.py

@@ -0,0 +1,56 @@
+from openai import OpenAI
+from ..types import AskOptions, AskResult, EmbedOptions, EmbedResult
+from typing import Callable
+
+def openai_ask(api_key: str, model: str, options: AskOptions, parse: Callable) -> AskResult:
+    client = OpenAI(api_key=api_key)
+
+    messages = []
+    if options.system:
+        messages.append({"role": "system", "content": options.system})
+    messages.append({"role": "user", "content": options.prompt})
+
+    res = client.chat.completions.create(
+        model=model,
+        messages=messages,
+        temperature=options.temperature,
+        max_tokens=options.max_tokens,
+    )
+
+    raw = res.choices[0].message.content or ""
+    return AskResult(data=parse(raw), raw=raw, provider="openai", model=model)
+
+def openai_stream(api_key: str, model: str, options: AskOptions):
+    client = OpenAI(api_key=api_key)
+
+    messages = []
+    if options.system:
+        messages.append({"role": "system", "content": options.system})
+    messages.append({"role": "user", "content": options.prompt})
+
+    res = client.chat.completions.create(
+        model=model,
+        messages=messages,
+        temperature=options.temperature,
+        max_tokens=options.max_tokens,
+        stream=True,
+    )
+
+    for chunk in res:
+        text = chunk.choices[0].delta.content
+        if text:
+            yield text
+
+def openai_embed(api_key: str, options: EmbedOptions) -> EmbedResult:
+    client = OpenAI(api_key=api_key)
+    model = options.model or "text-embedding-3-small"
+
+    input_list = options.input if isinstance(options.input, list) else [options.input]
+
+    res = client.embeddings.create(model=model, input=input_list)
+
+    return EmbedResult(
+        embeddings=[d.embedding for d in res.data],
+        model=model,
+        provider="openai",
+    )

abyss_ai_sdk-0.1.0/abyss/types.py

@@ -0,0 +1,33 @@
+from typing import Any, Generic, Literal, TypeVar
+from pydantic import BaseModel
+
+Provider = Literal["groq", "openai", "anthropic"]
+
+T = TypeVar("T")
+
+class AbyssConfig(BaseModel):
+  provider: Provider
+  api_key: str
+  model: str | None = None
+
+class AskOptions(BaseModel, Generic[T]):
+  prompt: str
+  system: str | None = None
+  schema: type[T] | None = None
+  temperature: float = 0.7
+  max_tokens: int = 1024
+
+class AskResult(BaseModel, Generic[T]):
+  data: T
+  raw: str
+  provider: Provider
+  model: str
+
+class EmbedOptions(BaseModel):
+  input: str | list[str]
+  model: str | None = None
+
+class EmbedResult(BaseModel):
+  embeddings: list[list[float]]
+  model: str
+  provider: Provider

abyss_ai_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "abyss-ai-sdk"
+version = "0.1.0"
+description = "Multi-provider AI utility with structured responses and streaming"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+dependencies = [
+    "groq>=0.9.0",
+    "openai>=1.0.0",
+    "anthropic>=0.25.0",
+    "pydantic>=2.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/Abyss-Systems/Abyss-SDK-Python"
+
+[tool.hatch.build.targets.wheel]
+packages = ["abyss"]