awesome-llm-apps：130k Stars LLM 应用精选合集

class TravelAgent:
    def __init__(self, llm, search_tool, booking_tool):
        self.llm = llm
        self.search = search_tool
        self.booking = booking_tool

    def plan_trip(self, destination, dates, budget):
        info = self.search.search(destination)
        itinerary = self.llm.generate(
            f"根据信息 {info} 制定 {dates} 的行程，预算 {budget}"
        )
        bookings = self.booking.book(itinerary)
        return {"itinerary": itinerary, "bookings": bookings}

from langchain.agents import Agent
from langchain.tools import PythonREPLTool

data_agent = Agent(
    llm=llm,
    tools=[
        PythonREPLTool(),        # 执行 Python 代码
        DataLoader(),             # 加载数据集
        VisualizationTool()       # 生成可视化
    ],
    prompt="你是一个专业的数据分析师，可以加载、清洗、分析数据并生成可视化"
)

result = data_agent.run(
    "加载 sales.csv，计算月环比增长率，生成趋势图"
)

from crewai import Agent, Task, Crew

market_agent = Agent(
    role="Market Analyst",
    goal="分析目标公司的市场份额和竞争格局",
    backstory="你是一名资深的行业分析师"
)

financial_agent = Agent(
    role="Financial Analyst",
    goal="评估公司的财务健康状况",
    backstory="你是一名资深的财务分析师"
)

legal_agent = Agent(
    role="Legal Analyst",
    goal="识别潜在的法律风险",
    backstory="你是一名资深律师"
)

crew = Crew(
    agents=[market_agent, financial_agent, legal_agent],
    tasks=[market_task, financial_task, legal_task],
    process="hierarchical"
)

result = crew.kickoff()

class SelfEvolvingAgent:
    def __init__(self, llm):
        self.llm = llm
        self.performance_history = []
        self.skills = {}

    def execute_task(self, task):
        result = self.llm.execute(task)
        score = self.evaluate_performance(result)
        self.performance_history.append({
            "task": task,
            "result": result,
            "score": score
        })

        if score < threshold:
            self.improve_strategy(task, result)

        return result

    def improve_strategy(self, task, result):
        failure_analysis = self.analyze_failure(task, result)
        improvement = self.llm.generate(
            f"分析以下失败案例并提出改进建议：{failure_analysis}"
        )
        self.update_strategy(improvement)

import chess
from langchain.agents import Agent

chess_agent = Agent(
    llm=llm,
    tools=[chess_ai_engine],
    prompt="你是一名国际象棋大师，可以分析棋局并制定最优策略"
)

board = chess.Board()
while not board.is_game_over():
    move = chess_agent.execute(
        f"当前棋局：{board.fen()}，请给出下一步棋"
    )
    board.push_san(move)
    print(f"Agent 走棋：{move}")

class VoiceRAGAgent:
    def __init__(self):
        self.stt = WhisperSTT()       # 语音转文字
        self.rag = RAGPipeline()      # RAG 检索
        self.tts = ElevenLabsTTS()    # 文字转语音

    def handle_voice_query(self, audio):
        query = self.stt.transcribe(audio)
        answer = self.rag.retrieve_and_generate(query)
        response_audio = self.tts.speak(answer)
        return response_audio

from mcp.client import MCPClient

browser_mcp = MCPClient("http://localhost:3000")

browser_agent = Agent(
    llm=llm,
    tools=[
        browser_mcp.navigate(url),
        browser_mcp.screenshot(),
        browser_mcp.click(selector),
        browser_mcp.type_text(text),
        browser_mcp.get_content(),
    ]
)

result = browser_agent.run(
    "访问 GitHub，搜索 awesome-llm-apps 仓库，获取 star 数量"
)

class MultiMCPRouter:
    def __init__(self, mcps):
        self.mcps = mcps

    async def route(self, query):
        intent = self.classify_intent(query)

        if "github" in intent:
            return await self.mcps["github"].process(query)
        elif "notion" in intent:
            return await self.mcps["notion"].process(query)
        elif "web" in intent:
            return await self.mcps["browser"].process(query)
        else:
            results = await asyncio.gather(*[
                mcp.process(query) for mcp in self.mcps.values()
            ])
            return self.synthesize(results)

from langchain.agents import Agent
from langchain.retrievers import VectorStoreRetriever

agentic_rag = Agent(
    llm=llm,
    tools=[
        VectorStoreRetriever(vectorstore),
        WebSearchTool(),
        KnowledgeGraphTool(),
    ],
    prompt="""你是一个研究助手。当用户提问时：
1. 先检索向量数据库
2. 如需最新信息，使用网络搜索
3. 如需关系信息，查询知识图谱
4. 综合所有来源生成答案"""
)

result = agentic_rag.run(
    "查找 2024 年 AI Agent 领域的最新研究进展"
)

from langchain_community.graphs import Neo4jGraph
from langchain_community.vectorstores import Chroma

graph = Neo4jGraph(url="bolt://localhost:7687", username="neo4j", password="password")
vectorstore = Chroma(persist_directory="./chroma_db")

def kg_enhanced_retrieval(query, top_k=5):
    vector_results = vectorstore.similarity_search(query, k=top_k)

    entities = extract_entities(query)
    kg_results = []
    for entity in entities:
        kg_results.extend(graph.query(f"""
            MATCH (e)-[r]-(related)
            WHERE e.name = '{entity}'
            RETURN e, r, related
            LIMIT 5
        """))

    combined = merge_results(vector_results, kg_results)
    answer = llm.generate(
        f"基于以下上下文回答：{combined}\n\n 问题：{query}"
    )
    return answer

class PersonalizedMemory:
    def __init__(self, llm, vectorstore):
        self.llm = llm
        self.memory_store = vectorstore
        self.user_profile = {}

    def update_memory(self, interaction):
        key_info = self.extract_key_info(interaction)
        self.memory_store.add_documents(key_info)
        self.user_profile.update(self.infer_preferences(interaction))

    def generate_response(self, query):
        relevant_memory = self.memory_store.similarity_search(
            query,
            filter={"user_id": self.user_id}
        )
        personalized_prompt = self.build_prompt(
            query=query,
            memory=relevant_memory,
            profile=self.user_profile
        )
        return self.llm.generate(personalized_prompt)

class ChatWithGitHub:
    def __init__(self, llm, github_token):
        self.github = GitHubAPI(token=github_token)
        self.llm = llm

    def chat_about_repo(self, repo_url, question):
        repo_info = self.github.get_repo_info(repo_url)
        code_snippets = self.github.search_code(
            repo=repo_url,
            query=question
        )
        answer = self.llm.generate(
            f"仓库信息：{repo_info}\n\n 相关代码：{code_snippets}\n\n 问题：{question}"
        )
        return answer

from google.adk.agents import Agent
from google.adk.tools import google_search, python_repl

research_agent = Agent(
    name="research_agent",
    model="gemini-2.0-flash",
    description="专业的研究助手",
    tools=[google_search, python_repl]
)

app = Agent(
    name="research_team",
    model="gemini-2.0-flash",
    agents=[research_agent],
    instruction="你是一个研究团队，可以协调多个专业研究员完成任务"
)

result = app.run("研究 2024 年 AI Agent 领域的最新进展")

from toonify import Toonifier

toonifier = Toonifier()

original = """
The user wants to create a new machine learning project.
We need to set up the environment, install dependencies,
configure the model, train the model, evaluate the results,
and deploy to production.
"""

compressed = toonifier.compress(original)
# 输出：USER→ML_PROJECT→ENV+DEPS+MODEL+TRAIN+EVAL+DEPLOY

restored = toonifier.restore(compressed)

from headroom import HeadroomOptimizer

optimizer = HeadroomOptimizer(
    max_tokens=8192,
    strategy="importance_based"
)

optimized_context = optimizer.optimize(
    full_context=long_context,
    query=current_query
)

response = llm.generate(optimized_context)

git clone https://github.com/Shubhamsaboo/awesome-llm-apps.git
cd awesome-llm-apps
pip install -r requirements.txt
export OPENAI_API_KEY="your-key"
export ANTHROPIC_API_KEY="your-key"
cd starter_ai_agents/ai_travel_agent
python app.py