Horizon: AI-Powered News Briefing Generator

What Horizon Does and Who It Is For

Horizon solves the problem of attention fragmentation across too many information sources. Good articles and discussions are spread across RSS feeds, forums, GitHub trending pages, and social platforms. Reading them all requires maintaining dozens of open tabs or subscriptions. Horizon collects from all those sources, applies a scoring and deduplication pass, and produces a ranked daily briefing that surfaces what is worth reading.

The README describes the core insight: different kinds of content need different treatment. A news event calls for context and impact. An engineering post calls for practical takeaways. A creator-oriented piece calls for content angles. The profile system lets each kind of content have its own scoring rubric and output format.

Horizon is aimed at engineers, researchers, and content creators who read from many sources regularly and want a filtered digest rather than a raw feed. The tool generates briefings in both English and Chinese, which makes it suitable for bilingual teams. Outputs can be delivered as Markdown files, published to GitHub Pages, or pushed to email and webhook endpoints including Feishu and WeChat.

Installing Horizon Locally

Horizon requires Python 3.11 or later. The recommended installation uses uv:

git clone https://github.com/Thysrael/Horizon.git
cd Horizon
uv sync

For test and development extras:

uv sync --extra dev

For the optional OpenBB financial news source:

uv sync --extra openbb

If openbb pulls packages without pre-built wheels for the target machine:

uv pip install --only-binary=:all: openbb openbb-benzinga

The recommended path for initial configuration is the interactive wizard:

uv run horizon-wizard

The wizard asks about interests and auto-generates `data/config.json`. Manual configuration copies the example files:

cp .env.example .env
cp data/config.example.json data/config.json

Configuring Sources, Profiles, and AI Providers

Horizon's configuration lives in two files: `.env` for API keys and `data/config.json` for source and processing settings. The `.env.example` file lists supported AI providers: OpenAI, Anthropic, Azure OpenAI, Google, Minimax, Dashscope, Doubao, and Deepseek.

A minimal config from the README shows the structure:

{
  "ai": {
    "provider": "openai",
    "model": "gpt-4",
    "api_key_env": "OPENAI_API_KEY"
  },
  "sources": {
    "rss": [
      {
        "name": "Simon Willison",
        "url": "https://simonwillison.net/atom/everything/",
        "profile": "tech-news"
      }
    ]
  },
  "processing": {
    "profiles_dir": "profiles",
    "default_profile": "tech-news",
    "profile_settings": {
      "tech-news": {
        "threshold": 7.0,
        "topic_dedup": true
      }
    }
  }
}

Each source can be assigned an explicit profile, or the profile field can be set to `"auto"` to let the AI choose from available profiles. An array value such as `["tech-news", "finance-news"]` restricts AI matching to those profiles.

Per-profile thresholds and deduplication settings belong in `processing.profile_settings`, not in the profile files themselves.

Profiles: Scoring Rules and Output Formats

A profile is a reusable set of editorial rules that controls what belongs in a briefing and how each item is treated. Horizon ships three built-in profiles.

`tech-news` is for technology events and context: it includes impact and community discussion where useful.

`tech-blog` is for engineering deep dives: it surfaces background, the solution described, and practical takeaways.

`ai-creator` is for AI creator material: it produces a summary and identifies timely hooks and content angles.

Assigning a profile to a source directs all content from that source through that profile's rules. The README notes that adapting an existing profile usually requires no Python changes. Profile files live in the `profiles/` directory and are bundled into the package at `src/_builtin_profiles`.

The balanced digest setting caps total briefing length and the share each category can occupy, so a single busy topic does not dominate.

Running with Docker

The repository includes a Dockerfile and a `docker-compose.yml` for containerized deployment. The Dockerfile uses Python 3.11 slim, installs uv, and accepts a comma-separated `EXTRAS` build argument for optional dependencies:

git clone https://github.com/Thysrael/Horizon.git
cd Horizon
docker compose build horizon

For optional extras at build time, pass the `--build-arg` flag:

docker compose build --build-arg EXTRAS=openbb horizon

The `docker-compose.yml` mounts `./data` and `./.env` as volumes and sets `TZ=UTC`. The `command` line passes `--hours 24` for a 24-hour lookback window. The README notes that the `twitter` extra requires Playwright browsers and system packages that the current Dockerfile does not install.

Limitations and Dependencies

Horizon requires an active LLM API key for every run. Every item that passes the deduplication filter is sent to the configured model for scoring and summarization. With many sources and a low threshold, API cost grows proportionally. The README does not document cost estimates; users should set conservative thresholds initially and monitor API usage.

The Twitter source requires the `twitter` extra, which pulls Playwright and system packages. The current Dockerfile does not install those packages, so Twitter as a source is not available in the default Docker image.

The MCP server (`horizon-mcp`) exposes pipeline stages to AI assistants, but the README notes that its configuration is in `src/mcp/README.md`, which is not included in the prompt material here.

An alternative to Horizon for pure feed aggregation without LLM processing is a self-hosted RSS reader such as FreshRSS or Miniflux, which stores and presents feed items without any AI scoring. The difference is that Horizon replaces the reading interface with a generated digest; it does not provide a browsable feed archive.

Horizon also requires careful source configuration to avoid noise. With broad RSS feeds and no profile threshold set, every item in the feed qualifies for the briefing and the LLM call count grows quickly. The `threshold` setting in `processing.profile_settings` is the main control for this: a value of 7.0 means only items the model scores 7 or above on a 10-point scale enter the briefing. Setting it too low defeats the filtering purpose; setting it too high risks missing relevant items. The README recommends starting from an autogenerated config via `horizon-wizard`, which sets defaults based on the interests you describe.

Editorial conclusion

Horizon is a good fit for engineers and researchers who read from many sources daily and want a ranked digest with context rather than a raw feed list. The profile system gives meaningful control over what gets included and how it is presented, without requiring Python changes for routine adjustments. The main constraint is the AI dependency: every run makes LLM API calls, so the cost scales with source volume and frequency. The Twitter source requires Playwright and system packages not included in the current Dockerfile. Python 3.11 or later is required. The MIT license permits any use including commercial deployment.

Frequently asked questions

Official sources

1. Official documentation
2. Official README
3. Project repository