Github Top Repositories

🔥 More models. Lower cost. One API key. Access GPT, Claude, Grok, Gemini, DeepSeek, Kimi, Qwen and more through one gateway. 💰 Better value Access leading models at prices below official API list rates. 🔌 One unified gateway Connect apps, agents and coding tools with one Smart API key. 📈 Clear costs Track every request, token and cost in one place. 🛡️ Reliable access Choose model groups with ordered fallback options. 👉 Models & pricing: https://modelflare.dev/pricing?utm_source=telegram&utm_medium=organic_social&utm_campaign=telegram_cn_202608&utm_content=value_models_one_api_v1 ⚡️ Create an account: https://modelflare.dev/sign-up?utm_source=telegram&utm_medium=organic_social&utm_campaign=telegram_cn_202608&utm_content=value_models_one_api_signup_v1 💬 Join the ModelFlare community: https://t.me/+GxEEPAsQ0ERiOGUx

Technical highlights - TurboQuant provides data‑oblivious quantization with near‑optimal distortion and no training overhead. - SIMD kernels operate on a vector‑major layout, allowing direct dot‑product computation without costly transposes. - On ARM, kernels use NEON SDOT/SMMLA; on x86 they leverage AVX‑512 VNNI and `vpermb`. - Benchmarks (100 K vectors, 1 K queries, k = 64) show median single‑thread speeds 3.4× faster than FAISS at 4‑bit and 20‑30 % faster at 2‑bit across both architectures. - Insertion latency per vector is 6‑20 µs (≈8‑14× faster than FAISS), and deletions are O(1) at sub‑microsecond cost. - Compression plots demonstrate up to 8× reduction in RAM vs raw float32. Who should use turbovec? - Engineers building Retrieval‑Augmented Generation (RAG) systems where memory, latency, or data‑privacy are critical. - Teams that need a drop‑in FAISS alternative but want better speed and smaller footprints. - Rust or Python developers who prefer a single‑library solution with native SIMD performance. - Anyone integrating vector stores into LangChain, LlamaIndex, Haystack, or custom pipelines. One‑liner takeaway lets you store massive embedding collections in a few gigabytes and search them faster than FAISS – all while staying completely local. ────────────────────────────── 🧠 Channel: https://t.me/GithubRe (2/2)

🚀 Meet RyanCodrai/turbovec: a gem from today's GitHub trending list. 🔗 https://github.com/RyanCodrai/turbovec 📝 A vector index built on TurboQuant, written in Rust with Python bindings ────────────────────────────── What is turbovec? is a fast, memory‑efficient vector search library written in Rust with Python bindings. It implements Google Research’s TurboQuant algorithm – a data‑oblivious quantizer that needs no separate training phase and delivers near‑optimal distortion. Why you’ll care - A 10 M‑document float‑32 corpus (~31 GB) fits in ~4 GB of RAM. - Search is consistently faster than FAISS IndexPQFastScan (≈3.4× speed‑up at 4‑bit, ≈20‑30 % at 2‑bit). - No “train‑then‑load” step – you can add vectors on the fly. - Incremental, crash‑safe persistence (`sync`) writes only what changed. - Built‑in filtering lets you restrict searches to an allow‑list without extra post‑processing. - Pure‑local deployment – perfect for privacy‑sensitive or latency‑critical RAG pipelines. Key features at a glance - Online ingest: `add()` vectors anytime; no rebuilding. - SIMD‑optimized search: hand‑written kernels (NEON SDOT/SMMLA, AVX‑512 VNNI, AVX2, scalar fallback). - Incremental saves: `sync(path)` persists deltas with a single fsync; full snapshots still available via `write`/`load`. - Filter‑aware search: pass an id allowlist or slot bitmask; the kernel skips irrelevant blocks. - Stable external IDs: `IdMapIndex` keeps your own uint64 identifiers and supports O(1) deletes. - Framework adapters: drop‑in replacements for LangChain, LlamaIndex, Haystack, Agno. Getting started – Python

pip install turbovec

from turbovec import TurboQuantIndex

# create a 1536‑dim index, 4‑bit quantization
index = TurboQuantIndex(dim=1536, bit_width=4)

# add vectors (numpy float32, shape (n, dim))
index.add(vectors)
index.add(more_vectors)

# search
scores, ids = index.search(query, k=10)

# persistence
index.write("my_index.tv")          # full snapshot
index.sync("my_index.tv")           # incremental, crash‑safe
loaded = TurboQuantIndex.load("my_index.tv")

Stable IDs example

from turbovec import IdMapIndex
import numpy as np

idx = IdMapIndex(dim=1536, bit_width=4)
idx.add_with_ids(vectors, np.array([1001, 1002, 1003], dtype=np.uint64))

scores, external_ids = idx.search(query, k=10)
idx.remove(1002)                     # O(1) delete by id
idx.sync("my_index.tvim")

Hybrid (filtered) search – combine a coarse external retriever with dense reranking:

allowed = np.array(db.execute(
    "SELECT id FROM docs WHERE tenant=?", (t,)
).fetchall(), dtype=np.uint64)

scores, ids = idx.search(query, k=10, allowlist=allowed)

The filter is evaluated inside the SIMD kernel, so only the allowed blocks incur any computation. Getting started – Rust

cargo add turbovec

use turbovec::TurboQuantIndex;

let mut index = TurboQuantIndex::new(1536, 4).unwrap();
index.add(&vectors);
let (scores, ids) = index.search(&queries, 10);
index.write("index.tv").unwrap();
let loaded = TurboQuantIndex::load("index.tv").unwrap();

(1/2)

🔍 Deep-diving into Tencent/AI-Infra-Guard — fresh off the trending list. 🔗 https://github.com/Tencent/AI-Infra-Guard 📝 A full-stack AI Red Teaming platform securing AI ecosystems via Agent Scan, Skills Scan, MCP scan, AI Infra scan and LLM jailbreak evaluation. ────────────────────────────── What is AI‑Infra‑Guard (A.I.G)? A.I.G is Tencent Zhuque Lab’s all‑in‑one AI red‑team platform. It bundles security scanners for AI models, AI‑agent skills, model‑centered components (MCP) and jailbreak evaluation, plus a marketplace for vetted security skills. In short, it lets you stress‑test your AI stack from code to deployment with a single, user‑friendly interface. Key Features 🔎 Skill‑Scan Engine – Detects nine categories of skill‑level risks (instruction hijacking, memory poisoning, code execution, privilege escalation, tool hijacking, insecure dependencies, etc.) and scores on the public SkillTrustBench leaderboard (top F1 0.9848 with Claude Opus 4.6). 🛡️ ClawScan (OpenClaw Security Scan) – One‑click audit of OpenClaw configurations, skill vulnerabilities, CVE exposures and privacy leaks. 🤖 Agent‑Scan – Automated multi‑agent framework that checks agent‑side skills, web‑exfiltration, OWASP‑style issues and more. 🧩 MCP‑Scan – Scans model‑centered components for tool poisoning, credential exfiltration, command injection and dozens of LLaMA cpp CVEs. 🚪 Jailbreak Evaluation – Runs multi‑turn jailbreak attacks (Many‑Shot, PAIR, GOAT, ActorAttack) to gauge model resistance. 🛒 AI Security Skill Market – Official marketplace where you can publish or acquire security‑hardened skills; the frontend is fully open‑sourced. ⚙️ Stand‑alone CLI Tools – aig-skill-scan, aig-agent-scan, aig-mcp-scan can be run independently or embedded into CI/CD pipelines. 📊 API‑Checker & Model Relay – Unified service that lists available LLM endpoints and validates request/response formats. How to Get Started 🐳 Docker (quickest)

git clone https://github.com/Tencent/AI-Infra-Guard.git
cd AI-Infra-Guard
docker-compose -f docker-compose.images.yml up -d

Open a browser at http://localhost:8088 to reach the web UI. 🚀 One‑Click Install Script (installs Docker if needed)

curl https://raw.githubusercontent.com/Tencent/AI-Infra-Guard/refs/heads/main/docker.sh | bash

🛠️ Python CLI for Skill Scan

pip install aig-skill-scan
export LLM_API_KEY="your-api-key"
aig-skill-scan --repo /path/to/skill \
               -m deepseek-v4-flash \
               --language en \
               -o result.json

🔧 Build from Source – Clone the repo, then run docker-compose up -d (or build the Go CLI with go build -o ai-infra-guard ./cmd/cli/main.go) for full control. Technical Highlights - Performance‑focused: Skill‑scan runs in parallel across LLM backends, achieving sub‑second latency on typical models. - Extensible rule base: > 2000 CVE rules, continuously updated; users can add custom policies via simple YAML. - Multi‑mode MCP scanning: Dynamic mode enforces tool whitelisting to block RCE attempts. - Zero‑trust deployment: Designed for internal enterprise use; no public auth layer, so keep it behind a firewall. - Cross‑language support: Scanners accept Python, JavaScript, and compiled bytecode (.pyc) with bypass detection. Who Should Use It? (1/2)

📌 Spotted on GitHub Trending: makeplane/plane — let's break it down. 🔗 https://github.com/makeplane/plane 📝 🔥🔥🔥 Open-source Jira, Linear, Monday, and ClickUp alternative. Plane is a modern project management platform to manage tasks, sprints, docs, and triage. ────────────────────────────── Plane – Modern, open‑source project management What’s it for? Plane is a self‑hostable (or cloud‑hosted) tool that lets teams track issues, run cycles (formerly sprints), organise roadmaps and keep all the project data in one tidy place – without the endless admin overhead that comes with many “all‑in‑one” solutions. Key features at a glance Work Items – Rich‑text task editor, file uploads, sub‑properties and cross‑issue linking. Cycles – Visual burn‑down charts and progress tracking to keep momentum. Modules – Break huge projects into bite‑size, manageable chunks. Views – Build custom filters, save them, and share with teammates. Pages – AI‑enhanced note‑taking with a full‑featured editor; turn notes into actionable items in a click. Analytics – Real‑time dashboards that surface trends, blockers and health metrics. How to get started 1. Plane Cloud (quick‑start) – Sign up at app.plane.so and you’re ready to go, no servers to manage. 2. Self‑hosted – Pick the deployment style that matches your ops stack.

# Docker‑Compose (most common)
git clone https://github.com/makeplane/plane.git
cd plane
docker compose up -d

For Kubernetes, follow the official guide (link in the repo). Managed‑hosting options like Zenith are also listed. Instance administration – Once up, admins can dive into “God mode” to tweak instance‑wide settings, data retention policies, SSO, etc. Technical highlights Frontend – Built with React Router, delivering a fast, SPA‑like experience. Backend – Powered by Django, handling complex relational data and permissions. Node.js – Supports the build pipeline and real‑time features. Rich‑text editing, file storage, and AI integrations are all open‑source, making extensions straightforward. Who should care? Product managers and scrum masters who need a lightweight yet powerful issue tracker. Engineering teams that want full control over data (self‑host) or a hassle‑free SaaS option. Open‑source enthusiasts looking to contribute to a modern Django + React stack. Start‑ups and small businesses that can’t afford pricey PM tools but still want analytics and custom views. Community & contribution – Plane thrives on feedback via its forum, GitHub Discussions, and the issue tracker. Documentation is split into product (how‑to) and developer (API, self‑hosting) sections. Security reports go to security@plane.so. The project is GPL‑3.0‑AGPL licensed, encouraging both use and contribution. Takeaway – Plane gives you the power of a full‑featured PM suite without locking you into a vendor, letting you focus on building, not on tool‑maintenance. ────────────────────────────── 🧠 Channel: https://t.me/GithubRe

curl -fsSL https://raw.githubusercontent.com/JuliusBrussee/caveman/v2.2.0/install.sh | bash

For a single agent you can also run the appropriate plugin command (Claude Code, Gemini CLI, etc.) – see the README for the exact syntax. Once installed, run caveman learn to see where your tokens leak, then let the tool guide you through safe, consent‑gated fixes. --- Technical highlights * Per‑type compressors – JSON (70‑90 % reduction), logs (85‑95 %), code (40‑70 %), diffs (60‑80 %), search results (80‑95 %), generic text/HTML (50‑80 %). * Tree‑sitter integration (Go, Python, JS/TS) for structural code compression; pure‑Go fallback for Go‑only environments. * BM25‑based relevance ranking combined with recency and error signals to pack the most useful context into the model’s token budget while preserving chronological order. * Content‑addressed “CCR” store guarantees byte‑exact recovery; every transformation is logged with a clear “decline reason” when it would enlarge the payload. * The proxy is a BSL‑1.1 runtime with an MIT‑licensed CLI – you can compile it yourself from source (Go + pnpm) if you prefer not to use the signed binaries. * Benchmarks (Claude Code, 54 runs) show a 33.2 % reduction in input tokens and unchanged answer correctness; pixel mode on a 63.7 k‑char JSON+log slab drops estimated tokens from ~55 k to ~11 k. --- Who should care? * Prompt engineers looking to squeeze more mileage out of token‑priced models. * Dev teams that run continuous LLM‑assisted coding, CI, or debugging pipelines and see their bills balloon. * Open‑source AI hobbyists using Claude, Gemini, Codex, or any of the 30+ supported agents. * Anyone who wants to keep the “brain” of their AI big while making the “mouth” tiny. --- Takeaway – Talk less, think more: Caveman lets your agents stay smart without swallowing the token bill. ────────────────────────────── 🧠 Channel: https://t.me/GithubRe (2/2)

🚀 Meet JuliusBrussee/caveman: a gem from today's GitHub trending list. 🔗 https://github.com/JuliusBrussee/caveman 📝 🪨 why use many token when few token do trick — Claude Code skill that cuts 65% of tokens by talking like caveman ────────────────────────────── Caveman is a tiny‑but‑mighty toolkit that teaches your AI agents to speak “caveman” – saying less while still saying the right thing. It trims the flood of tokens that LLM‑backed assistants pour into every request, cutting costs without sacrificing correctness. Why it matters Large‑language‑model providers charge per token, so every extra word, log line, or JSON payload inflates your bill. Caveman’s two‑pronged approach saves token usage on both sides: * Proxy mode – a local proxy that compresses what the model **reads** before it hits the provider. * Skill mode – a plug‑in that makes the model’s **answers** concise while keeping code, files, and errors byte‑exact. In a pinned Claude Code benchmark the proxy achieved 33.2 % fewer provider‑reported input tokens while passing all 18 exact‑answer checks. --- Key features 1. Caveman Proxy – One‑line wrapper around any supported agent (Claude, Gemini, Codex, …).   caveman claude or caveman wrap --pixel claude * Detects the payload type (JSON, log, code, diff, search result, plain text). * Applies a content‑aware compressor that keeps the bits the model actually needs. * Stores the original bytes in a content‑addressed “CCR” store; the model can retrieve them with caveman_retrieve. * Three safe modes:  • default – compresses when the transformation is smaller.  • --off – only measures, leaves data untouched.  • --pixel – renders dense text blocks to PNG so vision models see far fewer tokens. 2. Caveman Skill – Add a single skill to >30 agents so their replies are terse.   npx skills add JuliusBrussee/caveman * The model still receives full‑size tool results, files, and logs; only its spoken output is shortened. * Works with agents ranging from Claude Code to open‑source helpers like aider. 3. Learn & Implement – A local analyzer that scans months of your agent history, scores token “sinks”, and suggests one‑line fixes.   caveman learn – generates a “Cave Score” and a ranked list of wasteful patterns.   caveman learn implement – launches your own agent to propose diff‑style edits, applies only with your approval, and re‑measures the impact. 4. Pixel Mode – Turns massive text slabs into grayscale PNG pages, letting vision models ingest the same information for a fraction of the token price.   caveman wrap --pixel claude * Example: 8 622 characters become a 1568×232 PNG, estimated to drop from ~2 597 text tokens to ~534 image tokens. 5. TOON encoder/decoder – A custom JSON re‑encoder that shrinks repetitive structures when it proves beneficial.   caveman toon encode / caveman toon decode 6. Durable Memory – Store and recall raw bytes via caveman mem remember and caveman mem recall, enabling “off‑load” of frequently reused context. --- How to get started Install the CLI (global)

npm install -g @caveman-ai/cli && caveman setup --install
caveman claude        # choose your provider (claude, codex, gemini, …)

Add the skill to an existing agent

npx skills add JuliusBrussee/caveman

Full installer (covers 30+ agents, Windows, macOS, Linux) (1/2)

Integration highlights OpenViking provides ready‑made adapters for dozens of agents (Claude Code, Codex, OpenClaw, Hermes, Cursor, TRAE, LangChain, etc.). Each integration automatically injects recall calls and commits session memory, so you can upgrade an existing bot to “filesystem‑aware” context with a few configuration steps. Desktop helper (beta) – a GUI console for macOS and Windows that visualises session traces, manages local memory/skills, and syncs them to the server. VikingBot – an opinionated AI‑agent framework built on top of OpenViking. Install with pip install "openviking[bot]", start the server with --with-bot, and chat via ov chat. Production deployment – run the server as a standalone HTTP service, use the official Docker image, or follow the detailed deployment guide for scaling, monitoring, and secure configuration. Commercial edition note – the repository ships a fully functional, un‑restricted AGPL‑v3 edition. The commercial “Managed SaaS” offering is a hosted service, not a feature‑locked version. Takeaway: OpenViking turns AI memory into a searchable, tiered filesystem, giving agents the same transparent, file‑system tools developers already love. ────────────────────────────── 🧠 Channel: https://t.me/GithubRe (2/2)

🔍 Deep-diving into volcengine/OpenViking — fresh off the trending list. 🔗 https://github.com/volcengine/OpenViking 📝 Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills. ────────────────────────────── What is OpenViking? OpenViking is an open‑source “context database” that lets AI agents treat their memories, resources, and skills as a regular virtual filesystem accessed through the viking:// protocol. Instead of sending opaque vectors to a black‑box store, an agent can ls, tree and find its own context just like a developer works with files. Why it matters One filesystem for everything – memories, project docs, code snippets and reusable skills each appear as folders or files under a single URI scheme. Tiered loading (L0/L1/L2) – on write each entry is split into a short abstract (L0), a richer overview (L1) and the full detail (L2). The system only loads the layer deep enough for the current task, slashing token usage. Recursive, context‑aware retrieval – a vector search first picks the highest‑scoring directory, then drills down layer by layer, delivering results together with their surrounding context. Observable queries – every retrieval keeps a “browsing trajectory” you can inspect, making debugging wrong answers straightforward. Sessions become memory – after a session ends, OpenViking extracts preferences and experience into long‑term memory automatically. Key technical highlights Virtual viking:// URI hierarchy (e.g. viking://resources/…, viking://user/{id}/memories/…). Three‑tier content layers:

.abstract   # L0 ~100 tokens
.overview   # L1 ~2k tokens
(full file) # L2 full content, read on demand

Directory‑first vector search that preserves surrounding files, enabling “semantic‑aware” navigation. Built‑in observability: every query logs the exact path it followed. Plug‑and‑play integrations with major agents (Claude Code, OpenClaw, Hermes, LangChain, etc.) and support for multiple LLM providers (Volcengine, OpenAI, Ollama, Kimi, GLM). CLI ov for managing resources, browsing, and searching without writing code. Docker image and production‑grade HTTP service for scaling. Getting started in minutes

pip install openviking --upgrade
openviking-server init      # interactive wizard creates ~/.openviking/ov.conf
openviking-server doctor    # sanity‑check the config
openviking-server           # launch the background service

With the server running, the CLI lets you explore:

ov status
ov add-resource https://github.com/volcengine/OpenViking   # optional --wait
ov ls viking://resources/
ov tree viking://resources/volcengine -L 2
ov find "what is openviking"
ov grep "openviking" --uri viking://resources/volcengine/OpenViking/docs/en

If you just want to play, the web‑hosted OpenViking Studio offers a live demo with semantic search and a multi‑agent hub – no installation required. Who should use it? AI developers building agents that need deterministic, inspectable memory. Research teams experimenting with context‑engineering and long‑term memory. Product teams that want to give LLMs access to internal docs, codebases, and user preferences without leaking raw files. DevOps engineers looking for a self‑hosted, AGPL‑licensed alternative to proprietary vector stores. (1/2)