Scoopika

Scoopika provides an Agent abstraction that accepts parallel multimodal inputs (text, images, audio, URLs) in a single execution context, routing each input type to appropriate processors (vision-capable LLMs for images, speech-to-text for audio, web scrapers for URLs) before passing unified context to the LLM. The Agent class encapsulates LLM provider connections, tool bindings, memory management, and output validation, abstracting away the complexity of coordinating multiple input modalities.

Scoopika streams LLM responses token-by-token to the client via onToken hooks, enabling real-time UI updates and low-latency user feedback. The streaming architecture bypasses batch processing, allowing developers to render partial responses as they arrive rather than waiting for complete generation. This is particularly critical for voice applications where <300ms latency is claimed for voice response generation.

Scoopika abstracts LLM provider differences through a unified Agent interface, allowing developers to switch between OpenAI, Anthropic, Google, and other providers by changing configuration without modifying agent code. The platform claims to never share LLM credentials with Scoopika servers (credentials remain on developer's infrastructure), though the technical mechanism for this is undocumented. This enables provider flexibility and reduces vendor lock-in at the LLM layer.

Scoopika uses a freemium model with three tiers (Hobby free, Pro $25/mo, Scale $70/mo) that enforce quota limits on memory operations, voice processing, knowledge store queries, and audio processing. Each tier provides different monthly quotas (e.g., Pro: 1M memory reads, 500K writes; Scale: 4M reads, 2M writes), and exceeding quotas results in service degradation or blocking. This enables cost control and prevents runaway bills while allowing free experimentation on the Hobby tier.

Scoopika serves Knowledge Stores and Memory Stores from 26 global edge regions, reducing latency for knowledge retrieval and memory operations by serving requests from geographically close infrastructure. This edge-serving architecture is transparent to developers — they upload knowledge or create agents, and the platform automatically distributes and serves from the nearest region. Memory store region replication is available on the Scale tier ($70/mo) for additional redundancy.

Scoopika enables agents to invoke custom developer-defined functions, generic HTTP APIs, and built-in tools (Google Search) based on LLM reasoning about task requirements. The platform provides a tool registry mechanism where developers bind functions to the agent, and the LLM decides when and how to invoke them based on conversation context. Tool invocation is surfaced via onToolCall hooks, allowing developers to observe and potentially intercept function calls before execution.

Scoopika provides a managed Memory Store abstraction that persists conversation history across sessions with encryption at rest and optional region replication on higher tiers. Developers do not manage database infrastructure; the platform handles storage, encryption, and retrieval. Memory is tied to agent execution context and is automatically updated after each agent.run() call, enabling multi-turn conversations with full context retention without explicit state management code.

Scoopika provides a Knowledge Store abstraction that ingests files (PDFs, documents), websites, and raw text, converts them to vector embeddings, and serves them from 26 global edge regions. During agent execution, the platform automatically retrieves relevant knowledge snippets based on query similarity and augments the LLM prompt with retrieved context (Retrieval-Augmented Generation). Developers upload knowledge sources once and the platform handles embedding, indexing, caching, and retrieval without requiring vector database management.

Scoopika enables agents to generate validated JSON outputs by specifying a schema that the LLM must conform to. The platform enforces schema validation on LLM responses, ensuring structured data extraction (e.g., extracting contact information, scheduling details, or form fields) returns well-formed JSON matching the developer-defined schema. This prevents malformed or hallucinated JSON from being returned to the application.

Scoopika provides native voice I/O capabilities where audio input is transcribed to text, processed by the agent, and responses are synthesized back to audio with claimed <300ms latency for voice response generation. Audio processing is offered in two modes: 'fast' (2s average latency, quota-limited) and 'slow' (unlimited, ~10s latency). Voice responses are streamed in real-time, enabling natural voice-based conversational experiences without round-trip delays.

Scoopika accepts images as agent inputs and automatically routes them to vision-capable LLM providers (GPT-4V, Claude Vision, etc.) for visual understanding. Images can be passed alongside text, audio, and URLs in a single agent execution, enabling multimodal reasoning where the LLM analyzes visual content in context with other input modalities. Image format support and preprocessing are handled transparently by the platform.

Scoopika provides a built-in Google Search tool that agents can invoke to retrieve current information from the web during execution. The agent decides when to search based on task context (e.g., 'what's the current weather?' triggers a search), and search results are automatically integrated into the LLM prompt for grounded responses. This enables agents to answer questions about real-time information without relying solely on training data.

Scoopika is distributed as an npm package (@scoopika/scoopika) that can be integrated into any JavaScript/TypeScript web framework (Express, Next.js, Fastify, etc.) or deployed to serverless platforms (AWS Lambda, Vercel, Netlify, etc.). The library provides a client-side API (Scoopika class, Agent class) that developers use to instantiate and execute agents within their application code, with no framework-specific bindings or constraints. This enables flexible deployment patterns from monolithic servers to distributed serverless functions.