Solace Agent Mesh is a production-grade, full-stack platform for building, deploying, and managing event-driven multi-agent AI systems. It comprises a Python backend (FastAPI, Google ADK, SAC), a React/TypeScript web UI (chat, projects, workflows, prompts, scheduled tasks), a Click-based CLI, and a Docusaurus documentation site. The system uses a microservices-like architecture with separate gateway (HTTP/SSE), platform service (model configuration, storage), and agent components, all communicating via the Solace event broker and the A2A (Agent-to-Agent) protocol. Key entry points include the CLI (`solace-agent-mesh`), the web UI (`/chat`, `/projects`, `/workflows`), and the REST API (`/api/v1`). Data flows involve user requests via SSE, agent orchestration with workflow DAGs, tool execution (built-in, MCP, OpenAPI), artifact storage (S3/GCS/Azure/filesystem), and session persistence in SQL databases (SQLite/PostgreSQL/MySQL). External dependencies include a Solace broker, LLM endpoints (LiteLLM), optional databases, and cloud storage services. The repository is marked as deprecated (Development Status 7 β Inactive), with the new version being a desktop application.
ChatWiki is an open-source, multi-service AI chatbot and workflow automation platform primarily targeting the WeChat ecosystem. In production, it operates as a suite of Go microservices (chatwiki, message_service, code_run, websocket, plugin, llm_runner) behind a Gin web server, with a Vue 3 admin panel, separate mobile/PC/Electron frontends, and an embeddable SDK. The core functionality includes knowledge base management (document ingestion, chunking, vector storage with pgvector), a LogicFlow-based visual workflow builder, multi-channel messaging (WeChat Official Account, Mini Program, Feishu, DingTalk, Telegram, WhatsApp, LINE), and an AI agent framework called Clawbot with skill reuse. External dependencies include PostgreSQL (with pgvector and AGE graph extension), Redis, NSQ message queue, and optional Neo4j and E2B sandbox. While the system is primarily an application, it incorporates data-intensive components such as RAG pipelines, LLM request logging, and daily statistics, giving it a hybrid character.
CoexistAI is a research assistant framework implemented as a FastAPI application that provides a suite of API endpoints for web search, YouTube and Reddit retrieval, geospatial mapping, git repository analysis, text-to-speech/podcast generation, and knowledge base creation from local files or crawled websites. It integrates with an MCP server for agentic workflows and supports pluggable LLMs (Google, OpenAI, Ollama, local) and embedders (Google, HuggingFace, Infinity). The architecture is monolithic with modular utility functions, containerized via Docker with a companion SearxNG instance for privacy-respecting search. The codebase demonstrates a hybrid nature: while primarily an application with explicit API entry points, its core purpose is to support research and data-gathering tasks, making it equally relevant for data research scenarios. Configuration is centralized, and the system includes a web-based admin UI for runtime parameter changes. Active development is evident from recent commits and numerous utility modules, though some global mutable state and fallback-heavy code indicate where the system has evolved rapidly.
The OpenAI Cookbook is a sprawling collection of example code, notebooks, and guides for accomplishing tasks with the OpenAI API. It is not a single application but a repository of patterns. Its dominant character is data research and example code: it contains hundreds of Jupyter notebooks and Python scripts demonstrating embeddings, fine-tuning, RAG, agents, evals, MCP integrations, and vector database usage. The repo also includes full-stack demo applications (React/Next.js/Flask) for real-time translation, deployment management, and supply-chain copilots, making it a hybrid. There is no unified data lineage; instead, each example subsection defines its own data flow from API calls to local CSV/JSONL inputs. The quality is uneven: some eval harnesses and agent demos are well-structured, while many notebooks are scratchy and rely on inaccessible private data. The repository is maintained (last commit June 2026, CI workflows active) but shows medium technical drift, with some examples pinned to older library versions and many notebooks requiring manual environment setup.
This repository is a curated collection of 280+ n8n workflow templates, organized into 18 categories covering email automation, AI agents, RAG pipelines, social media, DevOps, document processing, and more. It is not a software application itself but a library of importable JSON workflow definitions for the n8n automation platform. The templates demonstrate practical automation patterns such as webhook-triggered AI agents, scheduled data enrichment, human-in-the-loop approvals, and vector-store-based retrieval-augmented generation. While the collection is extensive and popular (25k+ stars), individual templates vary in quality, with many containing hardcoded placeholders, deprecated model references, and no automated testing. The repository serves as a valuable reference for n8n users seeking ready-made automation blueprints, but users must adapt credentials and verify compatibility with their n8n version.
This repository is a large-scale educational resource and community showcase for building LLM-powered agents using the custom 'HelloAgents' framework. It is organized as a multi-chapter tutorial (16 chapters) covering agent fundamentals, tool use, memory systems, multi-agent protocols (MCP/A2A/ANP), context engineering, reinforcement learning (SFTβGRPO), and evaluation. Each chapter contains runnable code examples, and the repository also hosts 40+ community-contributed 'Co-creation-projects' that demonstrate real-world agent applications across domains including stock analysis, health record management, academic research, code assistance, game design, and data analysis. The architecture is not a single deployable system but a polyglot collection of independent projects, most following a FastAPI backend + Vue/React frontend pattern, with a shared dependency on the HelloAgents framework core. The primary data flow in each project is: user input β LLM reasoning loop (ReAct/Plan-and-Solve/Reflection) β tool execution (search, database, code execution, APIs) β memory/context update β response generation. External dependencies include OpenAI-compatible LLM APIs, search engines (Tavily, Brave, DuckDuckGo), vector stores (Qdrant, Milvus, Neo4j), and various domain-specific APIs (financial data, academic databases, weather). The codebase serves as both a learning path for agent development and a practical reference for common agent patterns, though quality varies significantly between the polished tutorial chapters and the prototype-level community projects.
This repository implements a full-stack AI-powered food recommendation application called 'δ»ε€©εδ»δΉ' (What to eat today). The system combines a Next.js frontend with a Python Flask backend that uses a GraphRAG (Retrieval-Augmented Generation) architecture leveraging Neo4j for graph-based recipe relationships and Milvus for vector similarity search. Users interact via a chat interface to receive personalized recipe recommendations with step-by-step cooking instructions. The application includes a comprehensive recipe knowledge base in markdown format, Docker-based deployment orchestration, and a modular RAG pipeline with intelligent query routing and session management.
This is an educational repository of Python scripts, mini-projects, and markdown guides for building LLM-based AI agents applied to cybersecurity. The code is organized into five progressive parts: foundational LLM/embeddings usage, prompt templates, prompt chaining, RAG over security data, and agentic workflows. It demonstrates multiple agent frameworks (LangChain, LangGraph, CrewAI, DeepAgents) and MCP server integrations for tools like nmap and Shodan. The dominant character is application/tutorial code rather than data research, although it bundles small datasets (CVE embeddings, sample RAG corpora) and commits Chroma vector stores for offline exercises. The repo is not a single deployable service; it is a collection of entry-point scripts and small frameworks. Architecture is a set of standalone examples with shared patterns: state graphs for orchestration, YAML-configured crews, MCP adapters, and RAG ingestion/query pipelines. Most scripts require OpenAI-compatible API keys and/or local tools such as nmap/Ollama. Simulated data and placeholder responses in some examples make it a learning environment rather than production security tooling. Maintenance is current but drift is moderate: some examples use deprecated langchain vectorstore imports, documentation is duplicated across subdirectories, several referenced files are missing, and hardcoded model strings like gpt-5.4-mini appear dated or fictional. There is no root-level automated test suite; only the Shodan MCP subproject contains tests. The strongest reusable patterns are the MCP server wrapping, LangGraph conditional-state orchestration, CrewAI declarative crew configuration, and the hierarchical SOC agent supervisor.
This repository is an 'awesome list' curated by the TeleAI-UAGI team, aggregating open-source and closed-source products, papers, benchmarks, tutorials, and surveys on memory systems for LLM/MLLM agents. It does not contain application business logic or runnable services; its primary output is a meticulously structured README.md that serves as a reference catalog. The accompanying Python scripts automate two maintenance tasks: (1) checking that open-source entries are ordered by GitHub star count and respecting a 100-star boundary for emerging projects, and (2) generating self-hosted star-history SVG charts. The scripts are well-crafted, with robust parsing, GitHub API integration, and careful edge-case handling (grace bands, orphan detection), making them reusable for other awesome-list maintainers. The repository's value lies in its curated content rather than its code, but the supporting infrastructure demonstrates solid engineering principles.
This repository is a curated community collection of 42 real-world use cases for OpenClaw (an AI agent framework), organized as markdown documentation. It is NOT a data pipeline, application, or research codebase itself β rather, it's an 'awesome list' style knowledge base documenting how practitioners use OpenClaw for tasks spanning social media automation, content pipelines, infrastructure management, personal productivity, research, and finance. Each use case file describes a workflow pattern, required skills/plugins, setup prompts, and architectural insights. The repo serves as a pattern catalog for agent-based automation. Classification as 'data_research' reflects the content's focus on data/engineering workflows (RAG, ETL, research pipelines, analytics), though the repo itself contains only documentation, not executable code or data.
This repository is an educational collection of minimal, from-scratch implementations of core LLM and generative AI systems, maintained by DataWhale. It is not a single production application; rather, it is a set of self-contained 'Tiny' sub-projects covering a small LLM trained on TinyStories, a RAG pipeline, a ReAct agent, an LLM evaluation harness, a DDPM diffusion model, a Transformer, a GraphRAG system, and an image-based RAG pipeline. Each sub-project has its own README, requirements, and runnable code or notebooks, with heavy Chinese-language comments explaining the underlying theory. The code is intentionally simple and readable rather than production-hardened, and it serves as a teaching resource for understanding how these systems work internally.
DemoGPT is an open-source Python framework that provides two core capabilities: (1) an automatic Streamlit application generator that converts natural language descriptions into complete, runnable Streamlit apps through a multi-stage LLM pipeline (planning, task decomposition, code generation, assembly), and (2) the DemoGPT AgentHub, a modular library for building AI agents with built-in tools (web search, code execution, Wikipedia, weather, etc.), two agent types (ToolCallingAgent for single-step tasks, ReactAgent for multi-step reasoning), and a RAG (Retrieval Augmented Generation) system supporting Chroma, FAISS, and Pinecone vector stores. The codebase is primarily a library/application hybrid, with the Streamlit app acting as both a user interface and a demonstration of the generation pipeline. The architecture separates concerns into chains, prompts, task definitions, and controllers, but many components are tightly coupled to the specific generation pipeline. The AgentHub portion is more modular and reusable. Technical drift is medium: the code uses deprecated LangChain APIs (LLMChain, Chain.run), hardcodes older models like gpt-3.5-turbo-16k in some generated code, and has a broad dependency range. Maintenance appears active with recent commits and responsive issue triage, but the codebase would benefit from modernizing to LangChain's new LCEL syntax and updating default models.
This repository is a personal cookbook and project showcase centered on the MiniCPM family of large language models (MiniCPM, MiniCPM-V, MiniCPM3). It contains over a dozen distinct application projects, including multi-modal OCR + visual grounding (OCR_VG), cross-modal image-text search, ReAct-style agent planning (agent_auto_plan), MBTI personality role-play, low-memory RAG (4G_memory_rag), AWQ quantization, embedding extraction, SFT/DPO fine-tuning pipelines, and Windows agent demos. Each project includes source code, shell scripts, and accompanying Chinese/English tutorials in markdown format. The codebase is primarily a collection of independent, loosely coupled modules rather than a unified application. It demonstrates practical usage of MiniCPM models for fine-tuning, deployment with vLLM/Ollama/llama.cpp, and integration with LangChain. The quality is functional but inconsistent: many modules contain hardcoded paths, duplicated logic, and lack tests, yet several components (ReAct data generation, image slicing utilities, LangChain wrapper) exhibit sufficient isolation and craftsmanship to be reusable across projects. The repo is actively maintained with a recent commit, but dependency on unmerged forks and version-specific model files poses a medium technical drift risk.
This repository is a comprehensive educational resource for learning and building AI agents using the LangGraph framework. It consists of numerous tutorials and examples organized by chapter, covering fundamental concepts such as state graphs and tool usage, as well as advanced patterns including Retrieval-Augmented Generation (RAG), multi-agent supervisor systems, and human-in-the-loop workflows. Each lesson is designed as a runnable script that demonstrates specific LangGraph integrations with various APIs (e.g., OpenAI, Tavily, OpenWeatherMap) and techniques like vector stores with Chroma. While the repository serves its purpose as a learning tool, it exhibits some maintenance challenges due to code duplication (e.g., multiple copies of display_graph.py across chapters) and contains at least one known flawed implementation (the audit data monitor in chapter13) that suffers from schema mismatches and inefficient API usage, as indicated by log files.
This repository is an educational cookbook from Upstage, centered on their Solar LLM and Document AI APIs. It contains a large collection of Jupyter notebooks (Solar-Fullstack-LLM-101) that teach prompt engineering, RAG, cache-augmented generation, tool calling, and fact-checking with knowledge graphs, plus a Flask sample backend (Bremen) and a Flutter mobile app. The dominant character is a notebook-driven ML/research collection, but it is hybrid because it includes runnable application code (Flask API, Flutter app) and static data assets (OCR JSON, CSV knowledge bases).
This repository is a tutorial and research exploration of Graph RAG (Retrieval-Augmented Generation) combining vector databases (Weaviate) and knowledge graphs (RDF/SPARQL). It contains Jupyter notebooks that demonstrate building knowledge graphs from PubMed articles, World Bank documents, and Netflix movies, comparing vector search and structured query performance for retrieval-augmented generation. A Streamlit app provides an interactive demo for medical article search with MeSH term refinement and LLM summarization. The code is primarily educational, with reusable query modules for Weaviate, RDF, and Databricks, but lacks dependency pinning and has hardcoded credentials, limiting reproducibility. The repository is hybrid, with both application (Streamlit app) and data research (notebooks, datasets) elements, but the dominant character is data research as the core value lies in the experimental notebooks and data pipelines.
This repository is a comprehensive tutorial and task collection for the 'InternLM Large Model Practical Camp' (Phase 3). It contains a series of learning modules (L0, L1, L2, EasterEgg) with detailed documentation, configuration files (e.g., XTuner, OpenCompass, LMDeploy), and example scripts for deploying, fine-tuning, and evaluating InternLM models. The repo is primarily educational, not a production software project. It demonstrates how to use the InternLM ecosystem (XTuner, LMDeploy, OpenCompass, Lagent, Huixiangdou, etc.) through hands-on tasks. The code is functional but lacks tests, CI/CD, and structured engineering practices. The repository is actively maintained (last commit recently) but has many open issues, indicating ongoing community support and updates. Technical drift is medium as it relies on specific pinned versions of tools like XTuner v0.1.21 and LMDeploy 0.5.3. It is best suited for learners and developers seeking to get started with InternLM and its toolchain.
This is a personal interview preparation and learning repository focused on large language model (LLM) algorithm positions. It contains extensive interview question logs from 2024-2026, organized by company, covering topics such as fine-tuning, RAG, RLHF, agent design, model architecture, and deployment. The repository also includes learning notes on transformer, CNN, RNN, LoRA, PEFT, and other LLM-related concepts, along with code implementations: a decoder-only transformer trained on Chinese text (ηΊ’ζ₯Όζ’¦), a reinforcement learning-based code optimizer using PPO, and various PyTorch examples. The utility scripts (DuckDB cache decorator, JSON extraction, logging, proxy management) are well-crafted and potentially reusable. However, the code components are explicitly unmaintained (the author states only interview records will receive future updates), and many paths are hardcoded. The interview notes are unstructured personal logs, not reusable as data assets without significant cleanup. The repo serves as a portfolio of technical capability and study material rather than a production system or reproducible data pipeline.
Flowise is an open-source, low-code platform for visually building AI agents, chatbots, and LLM-powered workflows. The monorepo contains a full-stack application: an Express/TypeORM backend (packages/server), a React/MUI frontend (packages/ui), a component library (packages/components) defining hundreds of pluggable nodes for LLMs, tools, memory, vector stores, and retrievers, a newer canvas SDK (packages/agentflow) for embedding agent flows, and an observability package (packages/observe) for execution monitoring. The platform supports multi-tenancy, RBAC, SSO, job queues (BullMQ), and enterprise features like usage quotas and audit logging. Despite being archived, the codebase demonstrates a comprehensive architecture for a visual AI orchestration platform with extensive third-party integrations (LangChain, LlamaIndex, OpenAI, Anthropic, etc.). However, the code exhibits significant technical drift: many nodes are marked as deprecated, database migrations are duplicated across four dialects, and there is evidence of incomplete migration from v1 to v2 canvas components. The repository is large and functionally rich, but its maintenance status (archived) and accumulation of deprecation warnings reduce its long-term viability.
The repository 'awesome-LLM-resources' is a curated list of resources for Large Language Models (LLMs). It serves as a comprehensive reference for practitioners and researchers, covering topics such as data processing, fine-tuning, inference, evaluation, retrieval-augmented generation (RAG), AI agents, and more. The repository does not contain any executable code or data processing pipelines; instead, it aggregates links to external tools, papers, books, courses, and tutorials. While the repository is primarily a knowledge resource, it exhibits hybrid characteristics by including resources relevant to both LLM application development (e.g., inference servers, agent frameworks) and data research (e.g., data extraction tools, evaluation benchmarks). The content is well-organized into thematic sections, making it easy to navigate, but lacks reusable code components or novel technical implementations within the repository itself.