arkitekt-next 0.8.48__py3-none-any.whl → 0.8.49__py3-none-any.whl

arkitekt_next/__blok__.py

@@ -4,7 +4,7 @@ from arkitekt_next.bloks.mikro import MikroBlok
 from arkitekt_next.bloks.fluss import FlussBlok
 from arkitekt_next.bloks.orkestrator import OrkestratorBlok
 from arkitekt_next.bloks.redis import RedisBlok
-from arkitekt_next.bloks.gateway import GatewayBlok
+from arkitekt_next.bloks.gateway import CaddyBlok
 from arkitekt_next.bloks.livekit import LocalLiveKitBlok
 from arkitekt_next.bloks.postgres import PostgresBlok
 from arkitekt_next.bloks.minio import MinioBlok
@@ -18,6 +18,8 @@ from arkitekt_next.bloks.rekuest import RekuestBlok
 from arkitekt_next.bloks.tailscale import TailscaleBlok
 from arkitekt_next.bloks.secret import SecretBlok
 from arkitekt_next.bloks.namegen import PreformedNamesBlok
+from arkitekt_next.bloks.ollama import OllamaBlok
+from arkitekt_next.bloks.self_signed import SelfSignedBlok
 
 
 def get_bloks():
@@ -27,11 +29,13 @@ def get_bloks():
         MikroBlok(),
         FlussBlok(),
         RedisBlok(),
-        GatewayBlok(),
+        CaddyBlok(),
         LocalLiveKitBlok(),
         PostgresBlok(),
         MinioBlok(),
+        OllamaBlok(),
         LokBlok(),
+        SelfSignedBlok(),
         KabinetBlok(),
         MountBlok(),
         ConfigBlok(),

arkitekt_next/bloks/arkitekt.py

@@ -1,16 +1,19 @@
+from typing import Any, Dict, Optional
+
 from pydantic import BaseModel
-from typing import Dict, Any
+
+from arkitekt_next.bloks.kraph import KraphBlok
 from arkitekt_next.bloks.tailscale import TailscaleBlok
-from blok import blok, InitContext, Renderer, Panel
-from .livekit import LocalLiveKitBlok
-from .mikro import MikroBlok
-from .kabinet import KabinetBlok
-from .rekuest import RekuestBlok
+from blok import InitContext, Panel, Renderer, blok
+
 from .fluss import FlussBlok
-from .gateway import GatewayBlok
 from .internal_docker import InternalDockerBlok
+from .kabinet import KabinetBlok
+from .livekit import LocalLiveKitBlok
+from .mikro import MikroBlok
 from .orkestrator import OrkestratorBlok
-from typing import Optional
+from .rekuest import RekuestBlok
+from .ollama import OllamaBlok
 
 
 class AdminCredentials(BaseModel):
@@ -19,8 +22,20 @@ class AdminCredentials(BaseModel):
     email: str
 
 
-@blok("live.arkitekt")
+@blok("live.arkitekt", dependencies=[
+    MikroBlok.as_dependency(True, True),
+    KabinetBlok.as_dependency(True, True),
+    RekuestBlok.as_dependency(True, True),
+    FlussBlok.as_dependency(True, True),
+    InternalDockerBlok.as_dependency(True, True),
+    OrkestratorBlok.as_dependency(True, True),
+    KraphBlok.as_dependency(True, False),
+    LocalLiveKitBlok.as_dependency(True, False),
+    TailscaleBlok.as_dependency(True, False),
+    OllamaBlok.as_dependency(True, False),
+])
 class ArkitektBlok:
+
     def entry(self, renderer: Renderer):
         renderer.render(
             Panel(
@@ -31,19 +46,6 @@ class ArkitektBlok:
             )
         )
 
-    def preflight(
-        self,
-        gateway: GatewayBlok,
-        livekit: Optional[LocalLiveKitBlok] = None,
-        mikro: Optional[MikroBlok] = None,
-        kabinet: Optional[KabinetBlok] = None,
-        rekuest: Optional[RekuestBlok] = None,
-        fluss: Optional[FlussBlok] = None,
-        internal_engine: Optional[InternalDockerBlok] = None,
-        scale: Optional[TailscaleBlok] = None,
-        orkestrator: Optional[OrkestratorBlok] = None,
-    ):
-        pass
 
     def build(self, cwd):
         pass

arkitekt_next/bloks/base.py

@@ -94,7 +94,9 @@ class BaseArkitektService:
             self.get_blok_meta().service_identifier, self.get_builder()
         )
 
-        dns_result = init.get_service(DnsService).get_dns_result()
+        django_secret = secret.retrieve_secret()
+
+        dns_result = dns.get_dns_result()
 
         csrf_trusted_origins = []
         for hostname in dns_result.hostnames:
@@ -108,7 +110,7 @@ class BaseArkitektService:
                     "admin": asdict(admin_access),
                     "debug": True,
                     "hosts": ["*"],
-                    "secret_key": self.secret_key,
+                    "secret_key": django_secret,
                 },
                 "redis": asdict(redis_access),
                 "lok": asdict(lok_access),

arkitekt_next/bloks/gateway.py

@@ -1,8 +1,9 @@
+from arkitekt_next.bloks.services.certer import CerterService
 from arkitekt_next.bloks.services.name import NameService
 from blok import blok, InitContext, ExecutionContext, Option
 from blok.tree import YamlFile, Repo
 from pydantic import BaseModel
-from typing import Dict, Any
+from typing import Dict, Any, Optional
 
 from blok import blok, InitContext
 from blok.bloks.services.dns import DnsService
@@ -34,7 +35,7 @@ class ExposedPort(BaseModel):
 @blok(
     "live.arkitekt.gateway", description="A gateway for exposing services on the host"
 )
-class GatewayBlok:
+class CaddyBlok:
     def __init__(self) -> None:
         self.exposed_hosts = {}
         self.exposed_to_hosts = {}
@@ -47,6 +48,8 @@ class GatewayBlok:
         self.https_port = 443
         self.public_ips = DEFAULT_PUBLIC_URLS
         self.public_hosts = DEFAULT_PUBLIC_HOSTS
+        self.cert_mount = None
+        self.depends_on = []
 
     def get_internal_host(self):
         return "caddy"
@@ -60,7 +63,7 @@ class GatewayBlok:
     def retrieve_gateway_network(self):
         return self.gateway_network
 
-    def preflight(self, init: InitContext, dns: DnsService, name: NameService):
+    def preflight(self, init: InitContext, dns: DnsService, name: NameService, certer: Optional[CerterService] = None):
         for key, value in init.kwargs.items():
             setattr(self, key, value)
 
@@ -68,6 +71,11 @@ class GatewayBlok:
         self.public_hosts = dns.get_dns_result().hostnames
         self.gateway_network = name.retrieve_name().replace("-", "_")
 
+        if certer is not None:
+            self.cert_mount = certer.retrieve_certs_mount()
+            self.depends_on = certer.retrieve_depends_on()
+        
+
     def build(
         self,
         context: ExecutionContext,
@@ -153,22 +161,25 @@ class GatewayBlok:
 
         context.file_tree.set_nested("configs", "Caddyfile", caddyfile)
 
-        caddy_depends_on = []
-        if self.with_certer:
-            caddy_depends_on.append("certer")
+        caddy_depends_on = self.depends_on
 
         exposed_ports_strings = [
             f"{port.port}:{port.port}" for port in self.exposed_ports.values()
         ]
 
+
+        volumes = ["./configs/Caddyfile:/etc/caddy/Caddyfile"]
+        if self.cert_mount:
+            volumes.append(f"{self.cert_mount}:/certs")
+
         caddy_container = {
             "image": "caddy:latest",
-            "volumes": ["./configs/Caddyfile:/etc/caddy/Caddyfile", "./certs:/certs"],
             "ports": [
                 f"{self.http_port}:80",
                 f"{self.https_port}:443",
             ]
             + exposed_ports_strings,
+            "volumes": volumes,
             "depends_on": caddy_depends_on,
             "networks": [self.gateway_network, "default"],
         }

arkitekt_next/bloks/internal_docker.py

@@ -17,7 +17,7 @@ class InternalDockerBlok:
     def __init__(self) -> None:
         self.host = "internal_docker"
 
-        self.image = "jhnnsrs/deployer:0.0.8-vanilla"
+        self.image = "jhnnsrs/deployer:nightly"
         self.instance_id = "INTERNAL_DOCKER"
 
     def preflight(
@@ -51,10 +51,6 @@ class InternalDockerBlok:
         if self.skip:
             return
         db_service = {
-            "labels": [
-                "fakts.service=io.livekit.livekit",
-                "fakts.builder=livekitio.livekit",
-            ],
             "image": self.image,
             "command": self.command,
             "volumes": [f"{self._socket}:/var/run/docker.sock"],

arkitekt_next/bloks/kraph.py

@@ -0,0 +1,42 @@
+import click
+from pydantic import BaseModel
+from typing import Dict, Any
+import yaml
+import secrets
+from blok import blok, InitContext
+
+from blok import blok, InitContext, ExecutionContext, Option
+from blok.tree import YamlFile, Repo
+from arkitekt_next.bloks.base import BaseArkitektService
+
+
+class AccessCredentials(BaseModel):
+    password: str
+    username: str
+    host: str
+    port: str
+    db_name: str
+
+
+@blok("live.arkitekt.kraph", description="Kraph allows you to interconnect structures in a graph database")
+class KraphBlok(BaseArkitektService):
+    def __init__(self) -> None:
+        self.dev = False
+        self.host = "kraph"
+        self.command = "bash run-debug.sh"
+        self.repo = "https://github.com/arkitektio/kraph-server"
+        self.scopes = {
+            "kraph_read": "Read from the graph database",
+            "mikro_write": "Write image to the database",
+        }
+        self.image = "jhnnsrs/kraph:nightly"
+        self.mount_repo = False
+        self.build_repo = False
+        self.buckets = ["media"]
+        self.secret_key = secrets.token_hex(16)
+
+    def get_builder(self):
+        return "arkitekt.generic"
+
+    def build(self, context: ExecutionContext):
+        context.docker_compose.set_nested("services", self.host, self.service)

arkitekt_next/bloks/lok.py

@@ -203,8 +203,8 @@ class LokBlok:
 
         db_service = {
             "labels": [
-                "fakts_next.service=live.arkitekt.lok",
-                "fakts_next.builder=arkitekt.lok",
+                "fakts.service=live.arkitekt.lok",
+                "fakts.builder=arkitekt.lok",
             ],
             "depends_on": depends_on,
             "volumes": [

arkitekt_next/bloks/ollama.py

@@ -0,0 +1,92 @@
+from typing import Dict, Any
+import secrets
+
+from arkitekt_next.bloks.services.gateway import GatewayService
+from arkitekt_next.bloks.services.ollama import OllamaService, OllamaCredentials
+from blok import blok, InitContext, ExecutionContext, Option
+from blok.tree import YamlFile, Repo
+
+
+@blok(OllamaService, description="a self-hosted Ollama LLM server")
+class OllamaBlok:
+    def __init__(self) -> None:
+        self.host = "ollama"
+        self.image = "ollama/ollama:latest"
+        self.port = 11434
+        self.skip = False
+        self.gpu = bool
+
+    def preflight(self, init: InitContext, gateway: GatewayService):
+        for key, value in init.kwargs.items():
+            setattr(self, key, value)
+
+
+        if self.skip:
+            return
+
+        gateway.expose_port_to(self.port, self.host, 11434, False)
+
+        self.initialized = True
+
+
+    def build(self, context: ExecutionContext):
+        if self.skip:
+            return
+        db_service = {
+            "labels": [
+                "fakts.service=io.ollama.ollama",
+                "fakts.builder=ollama.ollama",
+            ],
+            "image": self.image,
+            "environment": {
+                "OLLAMA_KEEP_ALIVE": "24h",
+            }
+        }
+
+        if self.gpu:
+            db_service["deploy"] = {
+                "resources": {
+                    "reservations": {
+                        "devices": [
+                            {
+                                "driver": "nvidia",
+                                "count": 1,
+                                "capabilities": ["gpu"],
+                            }
+                        ]
+                    }
+                }
+            }
+
+
+        context.docker_compose.set_nested("services", self.host, db_service)
+
+    def get_options(self):
+        with_host = Option(
+            subcommand="host",
+            help="The fakts url for connection",
+            default=self.host,
+        )
+        with_skip = Option(
+            subcommand="skip",
+            help="The fakts_next url for connection",
+            default=False,
+            type=bool,
+        )
+        with_gpu = Option(
+            subcommand="gpu",
+            help="Whether to use a gpu",
+            default=False,
+            type=self.gpu,
+        )
+
+        return [
+            with_host,
+            with_skip,
+            with_gpu,
+        ]
+
+    def __str__(self) -> str:
+        return (
+            f"LiveKitBlok(host={self.host}, command={self.command}, image={self.image})"
+        )

arkitekt_next/bloks/orkestrator.py

@@ -1,7 +1,9 @@
 from typing import Dict, Any
 import secrets
+from arkitekt_next.bloks.services.gateway import GatewayService
 from arkitekt_next.bloks.services.mount import MountService
 from blok import blok, InitContext, ExecutionContext, Option, Command
+from blok.bloks.services.dns import DnsService
 from blok.bloks.services.vscode import VsCodeService
 from blok.tree import Repo, YamlFile
 
@@ -14,6 +16,8 @@ class OrkestratorBlok:
     def __init__(self) -> None:
         self.dev = False
         self.disable = True
+        self.host = "orkestrator"
+        self.path_name = "orkestrator"
         self.repo = "https://github.com/arkitektio/orkestrator-next"
         self.build_command = ["yarn"]
         self.up_command = ["yarn", "start"]
@@ -21,36 +25,58 @@ class OrkestratorBlok:
     def preflight(
         self,
         init: InitContext,
+        gateway: GatewayService,
         mount: MountService,
         vscode: VsCodeService | None = None,
     ):
         for key, value in init.kwargs.items():
             setattr(self, key, value)
 
-        if self.disable and not self.dev:
+        if self.disable:
             return
-        self.mount = mount.register_mount("orkestrator", Repo(self.repo))
+        
+        if not self.dev:
+            gateway.expose(self.path_name, 80, self.host)
 
-        if vscode is not None:
-            vscode.register_task(
-                "Run Orkestrator",
-                "shell",
-                "yarn",
-                ["start"],
-                {"cwd": f"{self.mount}"},
-            )
-            vscode.register_task(
-                "Build Orkestrator",
-                "shell",
-                "yarn",
-                [],
-                {"cwd": f"{self.mount}"},
-            )
 
-        self.initialized = True
+            self.service = {
+                "image": "jhnnsrs/orkestrator_next:nightly",
+                "environment": {
+                    "PATH_NAME": self.path_name,
+                },
+            }
+
+            return 
+    
+        else:
+
+            self.mount = mount.register_mount("orkestrator", Repo(self.repo))
+
+            if vscode is not None:
+                vscode.register_task(
+                    "Run Orkestrator",
+                    "shell",
+                    "yarn",
+                    ["start"],
+                    {"cwd": f"{self.mount}"},
+                )
+                vscode.register_task(
+                    "Build Orkestrator",
+                    "shell",
+                    "yarn",
+                    [],
+                    {"cwd": f"{self.mount}"},
+                )
+
+            self.initialized = True
 
     def build(self, context: ExecutionContext):
-        if self.disable and not self.dev:
+        if self.disable:
+            return
+        
+        if self.dev:
+            context.docker_compose.set_nested("services", self.host, self.service)
+
             return
 
         context.install_commands.set_nested(
@@ -77,9 +103,21 @@ class OrkestratorBlok:
             help="Should we mount orkestrator as dev?",
             default=self.dev,
         )
+        with_path_name = Option(
+            subcommand="path_name",
+            help="The path name for the orkestrator service",
+            default=self.path_name,
+        )
+        with_host = Option(
+            subcommand="host",
+            help="The host for the orkestrator service",
+            default=self.host,
+        )
 
         return [
             with_dev,
             with_repos,
+            with_path_name,
             with_disable,
+            with_host,
         ]

arkitekt_next/bloks/self_signed.py

@@ -0,0 +1,98 @@
+from arkitekt_next.bloks.services.certer import CerterService
+from arkitekt_next.bloks.services.name import NameService
+from blok import blok, InitContext, ExecutionContext, Option
+from blok.tree import YamlFile, Repo
+from pydantic import BaseModel
+from typing import Dict, Any, Optional
+
+from blok import blok, InitContext
+from blok.bloks.services.dns import DnsService
+
+DEFAULT_PUBLIC_URLS = ["127.0.0.1"]
+DEFAULT_PUBLIC_HOSTS = ["localhost"]
+
+
+class ExposedHost(BaseModel):
+    host: str
+    port: int
+    stip_prefix: bool = True
+
+
+class ExpostedToHost(BaseModel):
+    port: int
+    host: str
+    to: str
+    tls: bool = False
+
+
+class ExposedPort(BaseModel):
+    port: int
+    host: str
+    tls: bool = False
+    to: int
+
+
+@blok(
+    "live.arkitekt.certer", description="A self-signed certificate generator"
+)
+class SelfSignedBlok:
+    def __init__(self) -> None:
+        self.host = "certer"
+        self.certer_image = "jhnnsrs/certer:next"
+        self.certs_mount = "./certs"
+
+    def retrieve_certs_mount(self):
+        return self.certs_mount
+
+
+    def retrieve_depends_on(self):
+        return ["certer"]
+
+    def preflight(self, init: InitContext, dns: DnsService):
+        for key, value in init.kwargs.items():
+            setattr(self, key, value)
+
+        self.public_ips = dns.get_dns_result().ip_addresses
+        self.public_hosts = dns.get_dns_result().hostnames
+
+
+    def build(
+        self,
+        context: ExecutionContext,
+    ):
+
+        context.file_tree.set_nested("certs", {})
+
+
+        certer_container = {
+            "image": self.certer_image,
+            "volumes": ["./certs:/certs"],
+            "environment": {
+                "DOMAIN_NAMES": ",".join(self.public_hosts),
+                "IP_ADDRESSED": ",".join(self.public_ips),
+            },
+        }
+
+        context.docker_compose.set_nested("services", self.host, certer_container)
+
+   
+
+    def get_options(self):
+        with_public_urls = Option(
+            subcommand="public_url",
+            help="Which public urls to use",
+            type=str,
+            multiple=True,
+            default=DEFAULT_PUBLIC_URLS,
+            show_default=True,
+        )
+        with_public_services = Option(
+            subcommand="public_hosts",
+            help="Which public hosts to use",
+            type=str,
+            multiple=True,
+            default=DEFAULT_PUBLIC_HOSTS,
+            show_default=True,
+        )
+
+        return [with_public_urls, with_public_services]

arkitekt_next/bloks/services/certer.py

@@ -0,0 +1,14 @@
+from blok import blok, InitContext, ExecutionContext, Option
+from blok.tree import YamlFile, Repo
+from dataclasses import dataclass
+from typing import Dict, Any, Protocol
+
+from blok import blok, InitContext, service
+
+
+@service("live.arkitekt.certer", description="Generate HTTPS certificates for services")
+class CerterService(Protocol):
+
+    def retrieve_certs_mount(self) -> str: ...
+        
+    def retrieve_depends_on(self) -> list[str]: ...

arkitekt_next/bloks/services/ollama.py

@@ -0,0 +1,16 @@
+from typing import Dict, Any, Protocol
+from blok import blok, InitContext, Option
+from blok import service
+from dataclasses import dataclass
+
+
+@dataclass
+class OllamaCredentials:
+    api_key: str
+    api_secret: str
+    api_url: str
+
+
+@service("io.ollama.ollama", description=" A self-hosted ollama LLM server")
+class OllamaService(Protocol):
+    pass

arkitekt_next/cli/commands/kabinet/build.py

@@ -233,8 +233,16 @@ def get_flavours(ctx: Context, select: Optional[str] = None) -> Dict[str, Flavou
     is_flag=True,
     default=False,
 )
+@click.option(
+    "--tag",
+    "-t",
+    help="Tag the build with a specific tag",
+    type=str,
+    default=None,
+    required=False,
+)
 @click.pass_context
-def build(ctx: Context, flavour: str, no_inspect: bool) -> None:
+def build(ctx: Context, flavour: str, no_inspect: bool, tag: str = None) -> None:
     """Builds the arkitekt_next app to docker"""
 
     manifest = get_manifest(ctx)
@@ -262,6 +270,10 @@ def build(ctx: Context, flavour: str, no_inspect: bool) -> None:
 
         build_tag = build_flavour(key, flavour)
 
+        if tag:
+            subprocess.run(["docker", "tag", build_tag, tag], check=True)
+
+
         inspection = None
         if not no_inspect:
             inspection = inspect_build(build_tag)

{arkitekt_next-0.8.48.dist-info → arkitekt_next-0.8.49.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arkitekt-next
-Version: 0.8.48
+Version: 0.8.49
 Summary: client for the arkitekt_next platform
 License: MIT
 Author: jhnnsrs
@@ -18,7 +18,7 @@ Provides-Extra: blok
 Provides-Extra: cli
 Provides-Extra: extended
 Provides-Extra: stream
-Requires-Dist: blok (>=0.0.19) ; (python_version >= "3.9" and python_version < "4.0") and (extra == "blok")
+Requires-Dist: blok (>=0.0.20) ; (python_version >= "3.9" and python_version < "4.0") and (extra == "blok")
 Requires-Dist: cryptography (>=40.0.8) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "blok")
 Requires-Dist: dokker (>=1.0.0)
 Requires-Dist: fakts-next (>=1.0.3)

{arkitekt_next-0.8.48.dist-info → arkitekt_next-0.8.49.dist-info}/RECORD

@@ -1,4 +1,4 @@
-arkitekt_next/__blok__.py,sha256=gQqlPrUPSeB-b3XkvXRwDoRWMfG-vYN-3a2pWHNjz_E,1563
+arkitekt_next/__blok__.py,sha256=kpITDqE6HDxXtQJ7v0Lr1iHCF-DXGNEjY5rS1VDwCBU,1716
 arkitekt_next/__init__.py,sha256=LKS5HkyEGSg4szUx-u0r1LLVRQ6FRo75OMxYGFX_oE8,1763
 arkitekt_next/apps/__init__.py,sha256=cx_5Y-RkJFkSQJH-hUEC_L3eW1jU2E426c4e6_csIyM,42
 arkitekt_next/apps/service/__init__.py,sha256=p4iRwiFBKRq2lfbjDBzUR_GMhPWjkjWTa01ohuKz_L4,157
@@ -11,26 +11,30 @@ arkitekt_next/apps/types.py,sha256=Ri6-Cby8bh9JOvMsOLpDrbeVB9zp3L28D951vM2juT0,1
 arkitekt_next/base_models.py,sha256=0jPEuvDPGwEgiuQcj5VN-8Ua_Tz3LhHAJq7t85-1inI,4116
 arkitekt_next/bloks/__init__.py,sha256=_4EeR63d6avQUWLG4mK2n_FvogTPQ_Jx6f2_RvNbWeA,29
 arkitekt_next/bloks/admin.py,sha256=mRTfjIR1vsfY1ghgjWLjKYFAOh1pGCmQ_IEt2QOR3og,1353
-arkitekt_next/bloks/arkitekt.py,sha256=ZyyHocaoPPCBZnbpBCkDzB2woXb1-ZbENr51UFERn2Q,1546
-arkitekt_next/bloks/base.py,sha256=6gsDc9sVYDqY4El2hhH32QiYHcYUd6eZQRgvhAuY2a0,6341
+arkitekt_next/bloks/arkitekt.py,sha256=OjsPAGn4Rr5GafR3Cg4bMdgy-J_uMAQUWdyeI85lxQk,1562
+arkitekt_next/bloks/base.py,sha256=Z4JS9Cyk7ba-ZH8UlibptkOTck5WZT7WhBkFW8GmAns,6364
 arkitekt_next/bloks/config.py,sha256=YMQChT4SCdc_vvvbkAj_qGyA--6JVEHds7MalqUp3lw,1269
 arkitekt_next/bloks/fluss.py,sha256=8nf5Z2k-tA3CNRQeIqh7-aaFe5my_NN2lAhbyYbwKEs,1074
-arkitekt_next/bloks/gateway.py,sha256=n3qhAcLj5LOxq6Tua2z0B7yvYh4hL9rG4sKNUD4F9iU,6757
-arkitekt_next/bloks/internal_docker.py,sha256=MLPS6rvcOPjkHF447gFXQu1AJvanp-zfb2F6Ekhf4Hk,2960
+arkitekt_next/bloks/gateway.py,sha256=yIseCS3wfEvHKn4B5ILVxuseCstefiNjaC4hLQZdSRo,7119
+arkitekt_next/bloks/internal_docker.py,sha256=oGAPKRMgdLM54xH7P9NiffMj0T264bjmlQlhwjHFQeA,2812
 arkitekt_next/bloks/kabinet.py,sha256=NKP6tpr8XcVvvFifX-lxgBPkP0P810kJ4URv25jf2z8,1489
+arkitekt_next/bloks/kraph.py,sha256=ySLOPbny_N2-M_ZaErCAStP0WtpEwM_4hszOsmFz4vw,1281
 arkitekt_next/bloks/livekit.py,sha256=S7Si7djl1s2hUckxxoawf6zUU93z_V3Mxl13PAy_4KI,2610
-arkitekt_next/bloks/lok.py,sha256=HErdQMlQdLwygiuGGVPLOM12XIR0exP43gyawWwN-5A,11575
+arkitekt_next/bloks/lok.py,sha256=QSYM4DejTOL4w6u-w6cLdJzy5KV3d14IOu7iPudKRpg,11565
 arkitekt_next/bloks/mikro.py,sha256=bnI9lWd6FXyOViog0Xko3_yhKOt7AAdB_PA4N0XkXAU,1291
 arkitekt_next/bloks/minio.py,sha256=n7DP_O49fBsMw4IWmHIspyNmc52l52q8fujcbAOgN7Q,5593
 arkitekt_next/bloks/mount.py,sha256=IEod6LDuV5NNKvvRJ3Xgo8l2caVZnNmJYDgGGBUB3Cg,1088
 arkitekt_next/bloks/namegen.py,sha256=W9xco2d3eJLdL2NYpTFmqw2d4s3vCpBREIFNm38gMYY,1087
-arkitekt_next/bloks/orkestrator.py,sha256=TJfMr6VCEU0EP_0TPpNdJsLVydGlmaDfYK1EQp2ArW8,2447
+arkitekt_next/bloks/ollama.py,sha256=F2j_gSyYonZ5QOuiA1UG0Kzi5vKLqiYx-UOj3NMafLQ,2528
+arkitekt_next/bloks/orkestrator.py,sha256=ZvK3dEtDeDsJC0n4QODhZXKItj3ybarVGnaxR107i_c,3556
 arkitekt_next/bloks/postgres.py,sha256=UbQnbedEUf_VKAfavz1sCGvAa-ZweDwrUeEj76lo_L8,4276
 arkitekt_next/bloks/redis.py,sha256=A9scMZohACsk-k1LQZo-rTFTB_eq12dqL4zVZkKdKLQ,2274
 arkitekt_next/bloks/rekuest.py,sha256=mfBjFKNGDMd9t1Wqkxeu2ZxAvYyMpAvHRS30PdchYCQ,1056
 arkitekt_next/bloks/secret.py,sha256=06J9f6-o1NCE0ReakVOyA0KbmQ-xr2fCYQWKOc_z1QQ,1067
+arkitekt_next/bloks/self_signed.py,sha256=ALkjO4C_S5n5gTEkVTMrshlLCK9LGkaW2-aS41J7oiU,2473
 arkitekt_next/bloks/services/__init__.py,sha256=i9vGNd1lFBem3O2PblTouRzFVQkdwOYoUmqqU43dIWQ,592
 arkitekt_next/bloks/services/admin.py,sha256=qeNa9KkFJk0DSNV-Ses-vkLjC3xHtvHnVHJ3w0DPKOA,463
+arkitekt_next/bloks/services/certer.py,sha256=BOeEXNhD1zb3rGB8VW8m9-LxZdFgHGk2PqTnbDVgP7M,446
 arkitekt_next/bloks/services/config.py,sha256=E0X-AweMxbbVQihqPuUEUzt9Y5J2DKY5sFX2efORtS0,378
 arkitekt_next/bloks/services/db.py,sha256=Lc8uL8xibz99-16YPxtB_ls6CP3dN_jCaOzJ9uZ8b_0,588
 arkitekt_next/bloks/services/gateway.py,sha256=X7ghhLXZ9hDQIMXMTkfBMcS9o9oc16y0C-b_3r3uwCo,847
@@ -38,6 +42,7 @@ arkitekt_next/bloks/services/livekit.py,sha256=5Qv1dcL2sQTveYvxZOuZPboNqn2wH0kyP
 arkitekt_next/bloks/services/lok.py,sha256=fzOGum0VmcVaONUhTv4jHYky4WrFq2ygDAYJjBv2vAI,500
 arkitekt_next/bloks/services/mount.py,sha256=UAp7IzUNGYtqrh8ACAVgRtc5jYVGvzsKjKdegBdK_i0,273
 arkitekt_next/bloks/services/name.py,sha256=ysr7b8Hn9yIeuBlqv9Zz-ngWKdQtwl3V1I1TeDvhLlA,254
+arkitekt_next/bloks/services/ollama.py,sha256=9L9DgUFcNxrYDg1p8W7THfzQmqQzBy0J7QTMhh-3WN8,352
 arkitekt_next/bloks/services/redis.py,sha256=W9CraIZJztFE1vQVCfxCxY4T_gBPRTM84VwFR8Hwtp8,472
 arkitekt_next/bloks/services/s3.py,sha256=_mk_9NdaeHRVZ__1M9CL1Ec1gSQKkzlOiQXse7MSx94,485
 arkitekt_next/bloks/services/secret.py,sha256=cnZsH09gN9YRXBbmalZaFD2LcmWLlfm52mDTAnfuYT4,344
@@ -66,7 +71,7 @@ arkitekt_next/cli/commands/inspect/requirements.py,sha256=bLYaWddScW2_qQFCwRtCFU
 arkitekt_next/cli/commands/inspect/templates.py,sha256=pymiXPTcpgKopt_nt-NC9hv4zxveQJQOMyndoPJ8knk,2286
 arkitekt_next/cli/commands/inspect/variables.py,sha256=LonDlbS2qH1v-jD6RfEhTv-mxmgeBMKqD3oO2iDJRjE,2698
 arkitekt_next/cli/commands/kabinet/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-arkitekt_next/cli/commands/kabinet/build.py,sha256=S6FF_tpS1Vu-1I2dvyMUa_pV1LWXnRt0wfPEddso0jc,8710
+arkitekt_next/cli/commands/kabinet/build.py,sha256=uQh0nPBGsQNJ8iy-cQwMjpNx1c2ZRrBybbyZYg5doVc,8957
 arkitekt_next/cli/commands/kabinet/init.py,sha256=YcxXlMick7Xd2XUjmA9vyku0QDGACw1PEWpfJum42E8,3600
 arkitekt_next/cli/commands/kabinet/main.py,sha256=U5EWekRTsMZZ34abWFfwilhzrd-zZtpZbl8RsLN_bC8,1008
 arkitekt_next/cli/commands/kabinet/publish.py,sha256=pbQ3QNNwSnyq06EPWfcJc_LoP9VhKo2wGBuUtNPPlV0,3572
@@ -135,8 +140,8 @@ arkitekt_next/qt/utils.py,sha256=MgBPtPmCSBkIuATov3UgREESwxAHh77lWNNxyE7Qs48,773
 arkitekt_next/service_registry.py,sha256=iGbTflBsL2HzCeulLUn1kRcuk_do9bdlQ881BIiE_HY,6276
 arkitekt_next/tqdm.py,sha256=lQcJI5Q6Py7Gy88hOCiJujjPEEGd8G2k1mOVJJ6oYe8,1531
 arkitekt_next/utils.py,sha256=4e4zEQSA7FZou8M01xV8oPBG1JvJJ0ySDP_nm3E3pMA,2390
-arkitekt_next-0.8.48.dist-info/LICENSE,sha256=YZ2oRjC248t-GpoEyw7J13vwKYNG6zhYMaEAix6EzF0,1089
-arkitekt_next-0.8.48.dist-info/METADATA,sha256=qj2F6gbFuf40PV92H1J6RJ_WxhFYjRbajaj4OmX2Kr4,6237
-arkitekt_next-0.8.48.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-arkitekt_next-0.8.48.dist-info/entry_points.txt,sha256=-hxikQx4xZ6TiOnWVDOlTN_kcAISgGFvTHXIchsCHSc,60
-arkitekt_next-0.8.48.dist-info/RECORD,,
+arkitekt_next-0.8.49.dist-info/LICENSE,sha256=YZ2oRjC248t-GpoEyw7J13vwKYNG6zhYMaEAix6EzF0,1089
+arkitekt_next-0.8.49.dist-info/METADATA,sha256=PJtbtjEXp9k6fR5lr0mOM_fhoXolBiqQwn0MaqB4Hjk,6237
+arkitekt_next-0.8.49.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+arkitekt_next-0.8.49.dist-info/entry_points.txt,sha256=-hxikQx4xZ6TiOnWVDOlTN_kcAISgGFvTHXIchsCHSc,60
+arkitekt_next-0.8.49.dist-info/RECORD,,