ciana-parrot

Self-hosted AI assistant with multi-channel support, scheduled tasks, and extensible skills

Stars: 53

Visit

Ciana Parrot is a lightweight and user-friendly tool for analyzing and visualizing data. It provides a simple interface for users to upload their datasets and generate insightful visualizations to gain valuable insights. With Ciana Parrot, users can easily explore their data, identify patterns, trends, and outliers, and communicate their findings effectively. The tool supports various data formats and offers a range of visualization options to suit different analysis needs. Whether you are a data analyst, researcher, or student, Ciana Parrot can help you streamline your data analysis process and make data-driven decisions with confidence.

README:

Self-hosted AI assistant with multi-channel support, scheduled tasks, and extensible skills.

What is CianaParrot?

CianaParrot is a self-hosted AI personal assistant that runs on your own infrastructure — sandboxed inside Docker, but connected to your OS through secure bridges. Built on the DeepAgents framework with LangChain/LangGraph, it combines interactive chat via Telegram (and other channels) with autonomous scheduled tasks — all configured through a single YAML file.

Key features:

Multi-provider LLM — Anthropic, OpenAI, Google Gemini, Groq, Ollama, OpenRouter, vLLM
Multi-channel — Pluggable architecture, Telegram out of the box
Host gateway system — Sandboxed in Docker, connected to your OS via a secure gateway. Each bridge exposes only allowed CLI commands — Spotify, Reminders, iMessage, Things, Bear Notes, Obsidian, 1Password, HomeKit, and more
Scheduled tasks — Cron, interval, and one-shot tasks
Web tools — Search (Brave / DuckDuckGo) and URL fetching built in
Skills system — Add a folder in skills/ with a SKILL.md and a skill.py, and it auto-registers
MCP support — Connect external MCP servers for unlimited extensibility
Persistent memory — Markdown-based identity and memory the agent updates itself
Observability — Optional LangSmith tracing for debugging and monitoring
Docker-only deploy — One command to build, one to run

Architecture

Quick Start

One-command install

curl -fsSL https://raw.githubusercontent.com/emanueleielo/ciana-parrot/main/install.sh | bash

This handles everything: prerequisites check, repo clone, .env setup (prompts for API keys), Docker build, and host gateway startup.

Flags: bash install.sh --dry-run to preview without changes, --no-prompt for non-interactive/CI usage.

Manual setup

If you prefer to set things up manually

1. Clone and configure

git clone https://github.com/emanueleielo/ciana-parrot.git
cd ciana-parrot
cp .env.example .env

Edit .env with your keys:

ANTHROPIC_API_KEY=sk-ant-...
TELEGRAM_BOT_TOKEN=123456:ABC-DEF...

Telegram bot token: Message @BotFather on Telegram, send /newbot, and follow the prompts.

2. Build and run

make build
make up

3. Start the host gateway

make gateway

Chat

Open your bot on Telegram, send /start, and start chatting.

Project Structure

cianaparrot/
├── config.yaml              # Single config file
├── .env                     # Secrets (API keys, tokens)
├── Dockerfile
├── docker-compose.yml
├── Makefile                 # build, up, down, logs, restart, shell, test
├── src/
│   ├── main.py              # Entry point, event loop, wiring
│   ├── agent.py             # DeepAgents setup, tools, memory
│   ├── agent_response.py    # Response extraction from LangGraph messages
│   ├── config.py            # YAML loader with ${ENV_VAR} expansion
│   ├── events.py            # Shared event types (tool calls, thinking, text)
│   ├── middleware.py         # Skill filtering (env vars, bridge requirements)
│   ├── router.py            # Trigger detection, auth, thread mapping
│   ├── scheduler.py         # Cron/interval/once task runner
│   ├── store.py             # JSON file-backed key-value store
│   ├── utils.py             # Text truncation utilities
│   ├── channels/
│   │   ├── base.py          # AbstractChannel interface
│   │   └── telegram/
│   │       ├── channel.py   # Telegram adapter + mode handler system
│   │       ├── formatting.py# Markdown → Telegram HTML conversion
│   │       ├── rendering.py # Tool display, sub-agent collapsing, icons
│   │       ├── utils.py     # Typing indicator
│   │       └── handlers/
│   │           └── claude_code.py  # Claude Code mode handler
│   ├── gateway/
│   │   ├── server.py        # Host-side HTTP gateway server (runs on host)
│   │   ├── client.py        # Gateway HTTP client (used by agent inside Docker)
│   │   └── bridges/
│   │       └── claude_code/
│   │           └── bridge.py# CC session management, CLI execution, NDJSON parsing
│   └── tools/
│       ├── web.py           # Web search + URL fetch
│       ├── cron.py          # Schedule/list/cancel tasks
│       └── host.py          # host_execute tool (gateway bridge commands)
├── workspace/
│   ├── IDENTITY.md          # Agent persona (name, tone, style)
│   ├── AGENT.md             # Behavioral instructions
│   ├── MEMORY.md            # Persistent memory (agent-updated)
│   └── sessions/            # JSONL conversation logs
├── skills/                  # Drop-in skill modules
└── data/
    ├── scheduled_tasks.json # Persisted scheduled tasks
    └── allowed_users.json   # Per-channel user allowlist

Configuration

Everything lives in config.yaml. Secrets are referenced as ${ENV_VAR} and expanded from .env at runtime. Config is validated at startup using Pydantic v2 models.

LLM Provider

Change provider by editing two lines:

provider:
  name: "anthropic"              # anthropic | openai | google-genai | groq | ollama
  model: "claude-sonnet-4-6"     # any model the provider supports
  api_key: "${ANTHROPIC_API_KEY}"

All supported providers

Provider	`name`	Example `model`	Env var
Anthropic	`anthropic`	`claude-sonnet-4-6`	`ANTHROPIC_API_KEY`
OpenAI	`openai`	`gpt-4o`	`OPENAI_API_KEY`
Google Gemini	`google-genai`	`gemini-2.0-flash`	`GOOGLE_API_KEY`
Groq	`groq`	`llama-3.3-70b-versatile`	`GROQ_API_KEY`
Ollama (local)	`ollama`	`llama3`	—
OpenRouter	`openai`	`anthropic/claude-sonnet-4-5`	`OPENROUTER_API_KEY`
vLLM	`openai`	`your-model`	—

For OpenRouter, Ollama, and vLLM add base_url:

provider:
  name: "openai"
  model: "anthropic/claude-sonnet-4-5"
  api_key: "${OPENROUTER_API_KEY}"
  base_url: "https://openrouter.ai/api/v1"

Additional provider options

provider:
  temperature: 0         # 0.0–2.0
  max_tokens: 8192       # Max tokens per response

Agent

agent:
  workspace: "./workspace"       # Root directory for agent files
  max_tool_iterations: 20        # Max tool calls per turn (default: 20)

Channels

channels:
  telegram:
    enabled: true
    token: "${TELEGRAM_BOT_TOKEN}"
    trigger: "@Ciana"        # Required prefix in group chats (ignored in DMs)
    allowed_users: []        # Empty = everyone allowed

Web Tools

web:
  brave_api_key: "${BRAVE_API_KEY}"  # Optional, falls back to DuckDuckGo
  fetch_timeout: 30                  # URL fetch timeout in seconds

MCP Servers

Connect external tools via Model Context Protocol:

mcp_servers:
  filesystem:
    transport: "stdio"
    command: "npx"
    args: ["-y", "@modelcontextprotocol/server-filesystem", "/data"]

  custom_api:
    transport: "sse"
    url: "http://localhost:8080/sse"

Scheduled Tasks

The agent can create scheduled tasks via chat (e.g., "remind me every Monday at 9am to check reports"). Tasks are persisted in data/scheduled_tasks.json.

scheduler:
  enabled: true
  poll_interval: 60              # Seconds between task checks
  data_file: "./data/scheduled_tasks.json"

Logging

logging:
  level: "INFO"                  # DEBUG | INFO | WARNING | ERROR

Host Gateway System

CianaParrot runs inside a Docker container — it can't see your filesystem, can't launch your apps, can't touch your OS. That's the point. The agent is sandboxed by default.

The gateway is a lightweight HTTP server that runs on the host and connects the sandboxed agent to specific host capabilities. Each bridge is a named connector that exposes only the CLI commands you explicitly allow — nothing more.

Docker Container (sandboxed)              Host (macOS/Linux)
┌─────────────────────────────┐    ┌─────────────────────────────────┐
│  CianaParrot Agent          │    │  Host Gateway (port 9842)       │
│                             │    │  ┌───────────────────────────┐  │
│  host_execute(bridge, cmd)──│───►│  │ claude-code  → claude     │  │
│                             │    │  │ spotify      → spogo      │  │
│  Can't see the host OS      │    │  │ apple-reminders → remindctl│  │
│  Can't escape the sandbox   │    │  │ imessage     → imsg       │  │
│                             │    │  │ whatsapp     → wacli      │  │
│                             │    │  │ ... 14 bridges total       │  │
│                             │    │  └───────────────────────────┘  │
└─────────────────────────────┘    └─────────────────────────────────┘

A prompt injection against CianaParrot can't compromise your entire system — only the specific CLI commands allowed by the active bridge's allowlist.

Available bridges

Bridge	CLI	Description
`claude-code`	`claude`	Claude Code sessions (Telegram `/cc` mode)
`spotify`	`spogo`	Playback control and queue management
`apple-reminders`	`remindctl`	Manage Apple Reminders lists and items
`things`	`things`	Things 3 task management
`imessage`	`imsg`	Send and read iMessages
`whatsapp`	`wacli`	WhatsApp messaging
`bear-notes`	`grizzly`	Bear notes app
`obsidian`	`obsidian-cli`	Read and write to your Obsidian vault
`sonos`	`sonos`	Sonos speaker control
`openhue`	`openhue`	Philips Hue smart lights
`camsnap`	`camsnap`	Camera snapshots
`peekaboo`	`peekaboo`	Screen capture
`blucli`	`blu`	Bluetooth device control
`1password`	`op`	Look up credentials (read-only)

How it works

The agent calls host_execute(bridge="spotify", command="spogo status") which sends an HTTP request to the gateway on the host. The gateway validates the command against the bridge's allowlist, executes it, and returns {stdout, stderr, returncode}.

For Claude Code, a dedicated Telegram mode (/cc) provides interactive sessions with project/conversation selection, streaming output, and tool-call rendering.

Skills declare requires_bridge: "spotify" in their YAML frontmatter — skills are automatically hidden when their required bridge isn't configured.

Setup

Add a gateway token to .env:

GATEWAY_TOKEN=any-secret-string-you-choose

Configure bridges in config.yaml:

gateway:
  enabled: true
  url: "http://host.docker.internal:9842"
  token: "${GATEWAY_TOKEN}"
  port: 9842
  bridges:
    spotify:
      allowed_commands: ["spogo"]
    apple-reminders:
      allowed_commands: ["remindctl"]

Install the CLI tools on the host (e.g., brew install steipete/tap/spogo)
Start the gateway on the host:
```
make gateway
```
Restart the bot:
```
make restart
```

Claude Code mode

Command	Description
`/cc`	Enter Claude Code mode — shows project list
`/cc exit`	Exit Claude Code mode

Once in CC mode:

Select a project from the paginated inline keyboard
Pick a conversation to resume, or start a new one
Send messages directly — they go to Claude Code instead of the main agent
Tool details button expands to show each tool call with its output

Adding a new bridge

Install the CLI tool on the host
Add a bridge entry in config.yaml under gateway.bridges with the CLI command in allowed_commands
Create a skill in skills/your-bridge/SKILL.md with requires_bridge: "your-bridge" in the frontmatter
Restart the bot — the skill auto-registers and the gateway allows the command

Skills

Add capabilities by dropping a folder in skills/:

skills/
└── weather/
    ├── SKILL.md    # Description + instructions for the agent
    └── skill.py    # Python functions auto-registered as tools

# skills/example/skill.py

def hello(name: str) -> str:
    """Say hello to someone."""
    return f"Hello, {name}!"

Functions with docstrings are auto-registered as agent tools by DeepAgents.

User Access Control

Edit data/allowed_users.json to restrict who can use the bot:

{
  "telegram": ["123456789", "987654321"]
}

Empty list = everyone allowed. Find your Telegram user ID via @userinfobot.

Commands

Command	Description
`/start`	Welcome message
`/help`	List all commands
`/new`	Reset conversation session
`/status`	System status
`/cc`	Enter Claude Code mode
`/cc exit`	Exit Claude Code mode

Observability

CianaParrot supports LangSmith for tracing and debugging agent execution. Add these to your .env:

LANGSMITH_API_KEY=lsv2_pt_...
LANGCHAIN_TRACING_V2=true
LANGCHAIN_PROJECT=ciana-parrot

All agent invocations (tool calls, LLM requests, memory operations) will appear as traces in LangSmith Studio.

Makefile

make build      # Build Docker image
make up         # Start in background
make down       # Stop
make logs       # Follow logs
make restart    # Rebuild and restart
make shell      # Shell into container
make test       # Run test suite (pytest)
make gateway    # Start host gateway on port 9842

Host Filesystem Access

The agent runs inside Docker and is sandboxed to the workspace/ directory. To let it read or write files on your host machine, mount host directories as subdirectories of workspace/ in docker-compose.yml:

volumes:
  - ./workspace:/app/workspace
  - /path/to/your/folder:/app/workspace/host/folder-name

The agent can then access the files using its built-in tools (ls, read_file, write_file, etc.) at host/folder-name/.

Read-only access

Append :ro to the volume mount to prevent the agent from modifying files:

- ~/Documents:/app/workspace/host/documents:ro

Read-write access

Omit the :ro suffix to allow the agent to create and edit files:

- ~/Projects:/app/workspace/host/projects

Example

services:
  cianaparrot:
    volumes:
      - ./workspace:/app/workspace
      - ./data:/app/data
      - ./skills:/app/skills
      - ./config.yaml:/app/config.yaml:ro
      - ~/Documents:/app/workspace/host/documents:ro
      - ~/Projects:/app/workspace/host/projects
      - ~/Notes:/app/workspace/host/notes

After editing docker-compose.yml, restart with make restart (or make build && make up if you also changed the image).

Customizing the Agent

The agent's behavior is fully controlled by three markdown files in workspace/:

File	Purpose
`IDENTITY.md`	Who the agent is — name, language, tone, personality
`AGENT.md`	How the agent behaves — tool usage rules, formatting guidelines
`MEMORY.md`	What the agent remembers — updated automatically across sessions

Edit these files and restart. No code changes needed.

Adding a New Channel

Create src/channels/myservice/ as a package
Implement the AbstractChannel interface (start, stop, send, send_file, on_message)
Add config section in config.yaml and a Pydantic model in src/config.py
Wire it up in src/main.py

License

MIT

For Tasks:

Click tags to check more tools for each tasks

explore data identify patterns detect outliers communicate findings make decisions

For Jobs:

data analyst researcher student business analyst marketing analyst

Alternative AI tools for ciana-parrot

Similar Open Source Tools

ciana-parrot

github

: 53

catwalk

Catwalk is a lightweight and user-friendly tool for visualizing and analyzing data. It provides a simple interface for users to explore and understand their datasets through interactive charts and graphs. With Catwalk, users can easily upload their data, customize visualizations, and gain insights from their data without the need for complex coding or technical skills.

github

: 588

ROGRAG

ROGRAG is a powerful open-source tool designed for data analysis and visualization. It provides a user-friendly interface for exploring and manipulating datasets, making it ideal for researchers, data scientists, and analysts. With ROGRAG, users can easily import, clean, analyze, and visualize data to gain valuable insights and make informed decisions. The tool supports a wide range of data formats and offers a variety of statistical and visualization tools to help users uncover patterns, trends, and relationships in their data. Whether you are working on exploratory data analysis, statistical modeling, or data visualization, ROGRAG is a versatile tool that can streamline your workflow and enhance your data analysis capabilities.

github

: 172

atlas

Atlas is a powerful data visualization tool that allows users to create interactive charts and graphs from their datasets. It provides a user-friendly interface for exploring and analyzing data, making it ideal for both beginners and experienced data analysts. With Atlas, users can easily customize the appearance of their visualizations, add filters and drill-down capabilities, and share their insights with others. The tool supports a wide range of data formats and offers various chart types to suit different data visualization needs. Whether you are looking to create simple bar charts or complex interactive dashboards, Atlas has you covered.

github

: 108

vizra-adk

Vizra-ADK is a data visualization tool that allows users to create interactive and customizable visualizations for their data. With a user-friendly interface and a wide range of customization options, Vizra-ADK makes it easy for users to explore and analyze their data in a visually appealing way. Whether you're a data scientist looking to create informative charts and graphs, or a business analyst wanting to present your findings in a compelling way, Vizra-ADK has you covered. The tool supports various data formats and provides features like filtering, sorting, and grouping to help users make sense of their data quickly and efficiently.

github

: 181

XRAG

XRAG is a powerful open-source tool for analyzing and visualizing data. It provides a user-friendly interface for data exploration, manipulation, and interpretation. With XRAG, users can easily import, clean, and transform data to uncover insights and trends. The tool supports various data formats and offers a wide range of statistical and machine learning algorithms for advanced analysis. XRAG is suitable for data scientists, analysts, researchers, and students looking to gain valuable insights from their data.

github

: 117

Daft

Daft is a lightweight and efficient tool for data analysis and visualization. It provides a user-friendly interface for exploring and manipulating datasets, making it ideal for both beginners and experienced data analysts. With Daft, you can easily import data from various sources, clean and preprocess it, perform statistical analysis, create insightful visualizations, and export your results in multiple formats. Whether you are a student, researcher, or business professional, Daft simplifies the process of analyzing data and deriving meaningful insights.

github

: 5.2k

CrossIntelligence

CrossIntelligence is a powerful tool for data analysis and visualization. It allows users to easily connect and analyze data from multiple sources, providing valuable insights and trends. With a user-friendly interface and customizable features, CrossIntelligence is suitable for both beginners and advanced users in various industries such as marketing, finance, and research.

github

: 67

datatune

Datatune is a data analysis tool designed to help users explore and analyze datasets efficiently. It provides a user-friendly interface for importing, cleaning, visualizing, and modeling data. With Datatune, users can easily perform tasks such as data preprocessing, feature engineering, model selection, and evaluation. The tool offers a variety of statistical and machine learning algorithms to support data analysis tasks. Whether you are a data scientist, analyst, or researcher, Datatune can streamline your data analysis workflow and help you derive valuable insights from your data.

github

: 101

arconia

Arconia is a powerful open-source tool for managing and visualizing data in a user-friendly way. It provides a seamless experience for data analysts and scientists to explore, clean, and analyze datasets efficiently. With its intuitive interface and robust features, Arconia simplifies the process of data manipulation and visualization, making it an essential tool for anyone working with data.

github

: 63

NadirClaw

NadirClaw is a powerful open-source tool designed for web scraping and data extraction. It provides a user-friendly interface for extracting data from websites with ease. With NadirClaw, users can easily scrape text, images, and other content from web pages for various purposes such as data analysis, research, and automation. The tool offers flexibility and customization options to cater to different scraping needs, making it a versatile solution for extracting data from the web. Whether you are a data scientist, researcher, or developer, NadirClaw can streamline your data extraction process and help you gather valuable insights from online sources.

github

: 99

datasets

Datasets is a repository that provides a collection of various datasets for machine learning and data analysis projects. It includes datasets in different formats such as CSV, JSON, and Excel, covering a wide range of topics including finance, healthcare, marketing, and more. The repository aims to help data scientists, researchers, and students access high-quality datasets for training models, conducting experiments, and exploring data analysis techniques.

github

: 21.2k

RAG-To-Know

RAG-To-Know is a versatile tool for knowledge extraction and summarization. It leverages the RAG (Retrieval-Augmented Generation) framework to provide a seamless way to retrieve and summarize information from various sources. With RAG-To-Know, users can easily extract key insights and generate concise summaries from large volumes of text data. The tool is designed to streamline the process of information retrieval and summarization, making it ideal for researchers, students, journalists, and anyone looking to quickly grasp the essence of complex information.

github

: 58

turftopic

Turftopic is a Python library that provides tools for sentiment analysis and topic modeling of text data. It allows users to analyze large volumes of text data to extract insights on sentiment and topics. The library includes functions for preprocessing text data, performing sentiment analysis using machine learning models, and conducting topic modeling using algorithms such as Latent Dirichlet Allocation (LDA). Turftopic is designed to be user-friendly and efficient, making it suitable for both beginners and experienced data analysts.

github

: 80

Aimer_WT

Aimer_WT is a web scraping tool designed to extract data from websites efficiently and accurately. It provides a user-friendly interface for users to specify the data they want to scrape and offers various customization options. With Aimer_WT, users can easily automate the process of collecting data from multiple web pages, saving time and effort. The tool is suitable for both beginners and experienced users who need to gather data for research, analysis, or other purposes. Aimer_WT supports various data formats and allows users to export the extracted data for further processing.

github

: 53

llm-d

LLM-D is a machine learning model for sentiment analysis. It is designed to classify text data into positive, negative, or neutral sentiment categories. The model is trained on a large dataset of labeled text samples and uses natural language processing techniques to analyze and predict sentiment in new text inputs. LLM-D is a powerful tool for businesses and researchers looking to understand customer feedback, social media sentiment, and other text data sources. It can be easily integrated into existing applications or used as a standalone tool for sentiment analysis tasks.

github

: 2.5k

For similar tasks

Eridanus

Eridanus is a powerful data visualization tool designed to help users create interactive and insightful visualizations from their datasets. With a user-friendly interface and a wide range of customization options, Eridanus makes it easy for users to explore and analyze their data in a meaningful way. Whether you are a data scientist, business analyst, or student, Eridanus provides the tools you need to communicate your findings effectively and make data-driven decisions.

github

: 176

ciana-parrot

github

: 53

pandas-ai

PandasAI is a Python library that makes it easy to ask questions to your data in natural language. It helps you to explore, clean, and analyze your data using generative AI.

github

: 14.0k

supersonic

SuperSonic is a next-generation BI platform that integrates Chat BI (powered by LLM) and Headless BI (powered by semantic layer) paradigms. This integration ensures that Chat BI has access to the same curated and governed semantic data models as traditional BI. Furthermore, the implementation of both paradigms benefits from the integration: * Chat BI's Text2SQL gets augmented with context-retrieval from semantic models. * Headless BI's query interface gets extended with natural language API. SuperSonic provides a Chat BI interface that empowers users to query data using natural language and visualize the results with suitable charts. To enable such experience, the only thing necessary is to build logical semantic models (definition of metric/dimension/tag, along with their meaning and relationships) through a Headless BI interface. Meanwhile, SuperSonic is designed to be extensible and composable, allowing custom implementations to be added and configured with Java SPI. The integration of Chat BI and Headless BI has the potential to enhance the Text2SQL generation in two dimensions: 1. Incorporate data semantics (such as business terms, column values, etc.) into the prompt, enabling LLM to better understand the semantics and reduce hallucination. 2. Offload the generation of advanced SQL syntax (such as join, formula, etc.) from LLM to the semantic layer to reduce complexity. With these ideas in mind, we develop SuperSonic as a practical reference implementation and use it to power our real-world products. Additionally, to facilitate further development we decide to open source SuperSonic as an extensible framework.

github

: 4.7k

DeepBI

DeepBI is an AI-native data analysis platform that leverages the power of large language models to explore, query, visualize, and share data from any data source. Users can use DeepBI to gain data insight and make data-driven decisions.

github

: 2.4k

WrenAI

WrenAI is a data assistant tool that helps users get results and insights faster by asking questions in natural language, without writing SQL. It leverages Large Language Models (LLM) with Retrieval-Augmented Generation (RAG) technology to enhance comprehension of internal data. Key benefits include fast onboarding, secure design, and open-source availability. WrenAI consists of three core services: Wren UI (intuitive user interface), Wren AI Service (processes queries using a vector database), and Wren Engine (platform backbone). It is currently in alpha version, with new releases planned biweekly.

github

: 12.0k

opendataeditor

The Open Data Editor (ODE) is a no-code application to explore, validate and publish data in a simple way. It is an open source project powered by the Frictionless Framework. The ODE is currently available for download and testing in beta.

github

: 148

Chat2DB

Chat2DB is an AI-driven data development and analysis platform that enables users to communicate with databases using natural language. It supports a wide range of databases, including MySQL, PostgreSQL, Oracle, SQLServer, SQLite, MariaDB, ClickHouse, DM, Presto, DB2, OceanBase, Hive, KingBase, MongoDB, Redis, and Snowflake. Chat2DB provides a user-friendly interface that allows users to query databases, generate reports, and explore data using natural language commands. It also offers a variety of features to help users improve their productivity, such as auto-completion, syntax highlighting, and error checking.

github

: 14.3k

For similar jobs

Azure-Analytics-and-AI-Engagement

The Azure-Analytics-and-AI-Engagement repository provides packaged Industry Scenario DREAM Demos with ARM templates (Containing a demo web application, Power BI reports, Synapse resources, AML Notebooks etc.) that can be deployed in a customer’s subscription using the CAPE tool within a matter of few hours. Partners can also deploy DREAM Demos in their own subscriptions using DPoC.

github

: 136

skyvern

Skyvern automates browser-based workflows using LLMs and computer vision. It provides a simple API endpoint to fully automate manual workflows, replacing brittle or unreliable automation solutions. Traditional approaches to browser automations required writing custom scripts for websites, often relying on DOM parsing and XPath-based interactions which would break whenever the website layouts changed. Instead of only relying on code-defined XPath interactions, Skyvern adds computer vision and LLMs to the mix to parse items in the viewport in real-time, create a plan for interaction and interact with them. This approach gives us a few advantages: 1. Skyvern can operate on websites it’s never seen before, as it’s able to map visual elements to actions necessary to complete a workflow, without any customized code 2. Skyvern is resistant to website layout changes, as there are no pre-determined XPaths or other selectors our system is looking for while trying to navigate 3. Skyvern leverages LLMs to reason through interactions to ensure we can cover complex situations. Examples include: 1. If you wanted to get an auto insurance quote from Geico, the answer to a common question “Were you eligible to drive at 18?” could be inferred from the driver receiving their license at age 16 2. If you were doing competitor analysis, it’s understanding that an Arnold Palmer 22 oz can at 7/11 is almost definitely the same product as a 23 oz can at Gopuff (even though the sizes are slightly different, which could be a rounding error!) Want to see examples of Skyvern in action? Jump to #real-world-examples-of- skyvern

github

: 20.5k

pandas-ai

PandasAI is a Python library that makes it easy to ask questions to your data in natural language. It helps you to explore, clean, and analyze your data using generative AI.

github

: 14.0k

vanna

Vanna is an open-source Python framework for SQL generation and related functionality. It uses Retrieval-Augmented Generation (RAG) to train a model on your data, which can then be used to ask questions and get back SQL queries. Vanna is designed to be portable across different LLMs and vector databases, and it supports any SQL database. It is also secure and private, as your database contents are never sent to the LLM or the vector database.

github

: 10.8k

databend

Databend is an open-source cloud data warehouse that serves as a cost-effective alternative to Snowflake. With its focus on fast query execution and data ingestion, it's designed for complex analysis of the world's largest datasets.

github

: 7.7k

Avalonia-Assistant

Avalonia-Assistant is an open-source desktop intelligent assistant that aims to provide a user-friendly interactive experience based on the Avalonia UI framework and the integration of Semantic Kernel with OpenAI or other large LLM models. By utilizing Avalonia-Assistant, you can perform various desktop operations through text or voice commands, enhancing your productivity and daily office experience.

github

: 113

marvin

Marvin is a lightweight AI toolkit for building natural language interfaces that are reliable, scalable, and easy to trust. Each of Marvin's tools is simple and self-documenting, using AI to solve common but complex challenges like entity extraction, classification, and generating synthetic data. Each tool is independent and incrementally adoptable, so you can use them on their own or in combination with any other library. Marvin is also multi-modal, supporting both image and audio generation as well using images as inputs for extraction and classification. Marvin is for developers who care more about _using_ AI than _building_ AI, and we are focused on creating an exceptional developer experience. Marvin users should feel empowered to bring tightly-scoped "AI magic" into any traditional software project with just a few extra lines of code. Marvin aims to merge the best practices for building dependable, observable software with the best practices for building with generative AI into a single, easy-to-use library. It's a serious tool, but we hope you have fun with it. Marvin is open-source, free to use, and made with 💙 by the team at Prefect.

github

: 5.9k

activepieces

Activepieces is an open source replacement for Zapier, designed to be extensible through a type-safe pieces framework written in Typescript. It features a user-friendly Workflow Builder with support for Branches, Loops, and Drag and Drop. Activepieces integrates with Google Sheets, OpenAI, Discord, and RSS, along with 80+ other integrations. The list of supported integrations continues to grow rapidly, thanks to valuable contributions from the community. Activepieces is an open ecosystem; all piece source code is available in the repository, and they are versioned and published directly to npmjs.com upon contributions. If you cannot find a specific piece on the pieces roadmap, please submit a request by visiting the following link: Request Piece Alternatively, if you are a developer, you can quickly build your own piece using our TypeScript framework. For guidance, please refer to the following guide: Contributor's Guide

github

: 21.0k