继续上一篇文章，开始进行下半部分翻译 关注AI、关注LLM大语言模型。问题或建议，请公众号留言。

使用 Google 的 A2A 协议、ADK 和 MCP 构建多智能体 AI 应用

---

架构

我们将使用与“旅行计划器”相同的架构，并扩展A2A + MCP协议。

旅行计划器架构图

以下演示仅用于说明如何理解多代理之间的 A2A 协议。

上述架构采用模块化多智能体 AI 系统，每个智能体均可独立部署，并使用 Google 的 A2A（Agent-to-Agent）协议进行通信。

上述架构的核心组件

• 用户界面层 - 向前端服务器发送 HTTP 请求
• 代理层 - 协调主机代理、代理 1 和代理 2
• 协议层 - 代理之间的 A2A 协议通信
• 外部数据层 - 使用 MCP 访问外部 API

代理角色：

• 行程规划代理 - 充当中央协调器 - 主机代理，协调用户与专业代理之间的交互。
• 航班搜索代理 - 负责根据用户输入获取航班选项的专用代理
• 酒店搜索代理 - 负责获取符合用户偏好的酒店住宿的专用代理

本项目中的 MCP 实现：

航班搜索 MCP 服务器

• 连接：航班搜索（代理 1）连接到 MCP 航班服务器
• 功能：连接到航班预订 API 和数据库

酒店搜索 MCP 服务器

• 连接：酒店搜索（代理 2）连接到 MCP 酒店服务器
• 功能：连接到酒店预订系统和聚合器

代理通信流程

• 用户通过 Streamlit UI 提交旅行查询
• 旅行计划器解析查询以提取关键信息
• 旅行计划器向航班搜索代理请求航班信息
• 航班搜索代理通过调用 MCP 服务器返回可用航班
• 旅行计划器提取目的地详情
• 旅行计划器向酒店搜索代理请求酒店信息
• 酒店搜索代理返回住宿选项
• 旅行计划器将所有数据整合成一份完整的行程

---

实现

让我们深入探讨如何使用 ADK + MCP + Gemini AI 构建这个多智能体，并分解为几个关键的实现步骤。

先决条件

• 安装 Python 3.11 及以上版本
• 通过 API 密钥访问 Google Gemini 生成式 AI
• 有效的 SerpAPI 密钥
• 有效的 OpenAI GPT 密钥

项目文件夹结构

1. ├── common
2. │├── __init__.py
3. │├── client
4. ││├── __init__.py
5. ││├── card_resolver.py
6. ││└── client.py
7. │├── server
8. ││├── __init__.py
9. ││├── server.py
10. ││├── task_manager.py
11. ││└── utils.py
12. │├── types.py
13. │└── utils
14. │├── in_memory_cache.py
15. │└── push_notification_auth.py
16. ├── flight_search_app
17. │├── a2a_agent_card.json
18. │├── agent.py
19. │├── main.py
20. │├──static
21. ││└──.well-known
22. ││└── agent.json
23. │└── streamlit_ui.py
24. ├── hotel_search_app
25. │├── README.md
26. │├── a2a_agent_card.json
27. │├── langchain_agent.py
28. │├── langchain_server.py
29. │├── langchain_streamlit.py
30. │├──static
31. ││└──.well-known
32. ││└── agent.json
33. │└── streamlit_ui.py
34. └── itinerary_planner
35. ├── __init__.py
36. ├── a2a
37. │├── __init__.py
38. │└── a2a_client.py
39. ├── a2a_agent_card.json
40. ├── event_log.py
41. ├── itinerary_agent.py
42. ├── itinerary_server.py
43. ├── run_all.py
44. ├──static
45. │└──.well-known
46. │└── agent.json
47. └── streamlit_ui.py

步骤 1：设置虚拟环境

安装依赖项

1. #Setup virtual env
2. python -n venv .venv 
4. #Activate venv
5. source .venv/bin/activate
7. #Install dependancies
8. pip install fastapi uvicorn streamlit httpx python-dotenv pydantic
9. pip install google-generativeai google-adk langchain langchain-openai

步骤 2：安装 MCP 服务器包

mcp 酒店服务器 — https://pypi.org/project/mcp-hotel-search/ mcp 航班服务器 — https://pypi.org/project/mcp-hotel-search/

1. #Install mcp search hotel
2. pip install mcp-hotel-search
4. #Install mcp flight search 
5. pip install mcp-flight-search

步骤 3：为 Gemini、OpenAI 和 SerpAI 设置环境变量

根据上述先决条件设置环境变量

1.  GOOGLE_API_KEY=your_google_api_key
2.  OPENAI_API_KEY=your_openai_api_key
3.  SERP_API_KEY=your_serp_api_key

步骤 4：使用 ADK 作为 MCP 客户端，使用 Gemini 2.0 Flash 设置航班搜索（代理）

以下设置与上一篇使用 ADK 的文章相同，但添加了 A2A 协议并使用了https://github.com/google/A2A/tree/main/samples/python/common 中的可复用模块

1. ├── common/# Shared A2A protocol components
2. │├── __init__.py
3. │├── client/# Client implementations
4. ││├── __init__.py
5. ││└── client.py                # Base A2A client
6. │├── server/# Server implementations
7. ││├── __init__.py
8. ││├── server.py                # A2A Server implementation
9. ││└── task_manager.py          # Task management utilities
10. │└── types.py                     # Shared type definitions for A2A

1. ├── flight_search_app/# Flight Search Agent (Agent 1)
2. │├── __init__.py
3. │├── a2a_agent_card.json          # Agent capabilities declaration
4. │├── agent.py                     # ADK agent implementation
5. │├── main.py                      # ADK Server entry point Gemini LLM
6. │└──static/# Static files
7. │└──.well-known/# Agent discovery directory
8. │└── agent.json           # Standardized agent discovery file

4.1 ADK 代理实现作为 MCP 客户端从 MCP 服务器获取工具

1. from google.adk.agents.llm_agent importLlmAgent
2. from google.adk.tools.mcp_tool.mcp_toolset importMCPToolset,StdioServerParameters
4. ..
5. ..
6. # Fetch tools from MCP Server 
7. server_params =StdioServerParameters(
8.             command="mcp-flight-search",
9.             args=["--connection_type","stdio"],
10.             env={"SERP_API_KEY": serp_api_key},)
13. tools, exit_stack =awaitMCPToolset.from_server(
14.             connection_params=server_params)
15. ..
16. ..

4.2 使用常见的 A2A 服务器组件和类型以及 google ADK 运行器、会话和代理的 ADK 服务器入口点定义

1. from google.adk.runners importRunner
2. from google.adk.sessions importInMemorySessionService
3. from google.adk.agents importAgent
4. from.agent import get_agent_async
6. # Import common A2A server components and types
7. from common.server.server import A2AServer
8. from common.server.task_manager importInMemoryTaskManager
9. from common.types import(
10. AgentCard,
11. SendTaskRequest,
12. SendTaskResponse,
13. Task,
14. TaskStatus,
15. Message,
16. TextPart,
17. TaskState,
18. )
21. # --- Custom Task Manager for Flight Search --- 
22. classFlightAgentTaskManager(InMemoryTaskManager):
23. """Task manager specific to the ADK Flight Search agent."""
24. def __init__(self, agent:Agent, runner:Runner, session_service:InMemorySessionService):
25. super().__init__()
26. self.agent = agent 
27. self.runner = runner 
28. self.session_service = session_service 
29.         logger.info("FlightAgentTaskManager initialized.")
31. ...
32. ...

4.3 使用 Agent Card 创建 A2A 服务器实例

1. # --- Main Execution Block --- 
2. asyncdef run_server():
3. """Initializes services and starts the A2AServer."""
4.     logger.info("Starting Flight Search A2A Server initialization...")
6.     session_service =None
7.     exit_stack =None
8. try:
9.         session_service =InMemorySessionService()
10.         agent, exit_stack =await get_agent_async()
11.         runner =Runner(
12.             app_name='flight_search_a2a_app',
13.             agent=agent,
14.             session_service=session_service,
15. )
17. # Create the specific task manager
18.         task_manager =FlightAgentTaskManager(
19.             agent=agent,
20.             runner=runner,
21.             session_service=session_service
22. )
24. # Define Agent Card
25.         port =int(os.getenv("PORT","8000"))
26.         host = os.getenv("HOST","localhost")
27.         listen_host ="0.0.0.0"
29.         agent_card =AgentCard(
30.             name="Flight Search Agent (A2A)",
31.             description="Provides flight information based on user queries.",
32.             url=f"http://{host}:{port}/",
33.             version="1.0.0",
34.             defaultInputModes=["text"],
35.             defaultOutputModes=["text"],
36.             capabilities={"streaming":False},
37.             skills=[
38. {
39. "id":"search_flights",
40. "name":"Search Flights",
41. "description":"Searches for flights based on origin, destination, and date.",
42. "tags":["flights","travel"],
43. "examples":["Find flights from JFK to LAX tomorrow"]
44. }
45. ]
46. )
48. # Create the A2AServer instance
49.         a2a_server = A2AServer(
50.             agent_card=agent_card,
51.             task_manager=task_manager,
52.             host=listen_host,
53.             port=port
54. )
55. # Configure Uvicorn programmatically
56.         config = uvicorn.Config(
57.             app=a2a_server.app,# Pass the Starlette app from A2AServer
58.             host=listen_host,
59.             port=port,
60.             log_level="info"
61. )
62.         server = uvicorn.Server(config)
63. ...
64. ...

4.4 启动航班搜索应用程序

步骤 5：使用 LangChain 作为 MCP 客户端并使用 OpenAI（GPT-4o）作为 LLM 配置酒店搜索代理

1. ├── hotel_search_app/# Hotel Search Agent (Agent 2)
2. │├── __init__.py
3. │├── a2a_agent_card.json          # Agent capabilities declaration
4. │├── langchain_agent.py           # LangChain agent implementation
5. │├── langchain_server.py          # Server entry point
6. │└──static/# Static files
7. │└──.well-known/# Agent discovery directory
8. │└── agent.json           # Standardized agent discovery file

5.1. 使用 OpenAI LLM 实现 LangChain Agent 作为 MCP 客户端

1. from langchain_openai importChatOpenAI
2. from langchain.agents importAgentExecutor, create_openai_functions_agent
3. from langchain.prompts importChatPromptTemplate,MessagesPlaceholder
4. from langchain_mcp_adapters.client importMultiServerMCPClient
6. # MCP client configuration
7. MCP_CONFIG ={
8. "hotel_search":{
9. "command":"mcp-hotel-search",
10. "args":["--connection_type","stdio"],
11. "transport":"stdio",
12. "env":{"SERP_API_KEY": os.getenv("SERP_API_KEY")},
13. }
14. }
16. classHotelSearchAgent:
17. """Hotel search agent using LangChain MCP adapters."""
19. def __init__(self):
20. self.llm =ChatOpenAI(model="gpt-4o", temperature=0)
22. def _create_prompt(self):
23. """Create a prompt template with our custom system message."""
24.         system_message ="""You are a helpful hotel search assistant. 
25.         """
27. returnChatPromptTemplate.from_messages([
28. ("system", system_message),
29. ("human","{input}"),
30. MessagesPlaceholder(variable_name="agent_scratchpad"),
31. ])
32. ..
33. ..
34. asyncdef process_query(self, query):
35. ...
37. # Create MCP client for this query
38. asyncwithMultiServerMCPClient(MCP_CONFIG)as client:
39. # Get tools from this client instance
40.                 tools = client.get_tools()
42. # Create a prompt
43.                 prompt =self._create_prompt()
45. # Create an agent with these tools
46.                 agent = create_openai_functions_agent(
47.                     llm=self.llm,
48.                     tools=tools,
49.                     prompt=prompt
50. )
52. # Create an executor with these tools
53.                 executor =AgentExecutor(
54.                     agent=agent,
55.                     tools=tools,
56.                     verbose=True,
57.                     handle_parsing_errors=True,
58. )

5.2 使用常见的 A2A 服务器组件和类型创建 A2AServer 实例

1. # Use the underlying agent directly
2. from hotel_search_app.langchain_agent import get_agent,HotelSearchAgent
4. # Import common A2A server components and types
5. from common.server.server import A2AServer
6. from common.server.task_manager importInMemoryTaskManager
7. from common.types import(
8. AgentCard,
9. SendTaskRequest,
10. SendTaskResponse,
11. Task,
12. TaskStatus,
13. Message,
14. TextPart,
15. TaskState
16. )
17. ..
18. ..
20. classHotelAgentTaskManager(InMemoryTaskManager):
21. """Task manager specific to the Hotel Search agent."""
22. def __init__(self, agent:HotelSearchAgent):
23. super().__init__()
24. self.agent = agent # The HotelSearchAgent instance
25.         logger.info("HotelAgentTaskManager initialized.")
27. asyncdef on_send_task(self, request:SendTaskRequest)->SendTaskResponse:
28. """Handles the tasks/send request by calling the agent's process_query."""
29.         task_params = request.params
30.         task_id = task_params.id
31.         user_message_text =None
33.         logger.info(f"HotelAgentTaskManager handling task {task_id}")
36. # --- Main Execution Block --- 
37. asyncdef run_server():
38. """Initializes services and starts the A2AServer for hotels."""
39.     logger.info("Starting Hotel Search A2A Server initialization...")
41.     agent_instance:Optional[HotelSearchAgent]=None
42. try:
43.         agent_instance =await get_agent()
44. ifnot agent_instance:
45. raiseRuntimeError("Failed to initialize HotelSearchAgent")
47. # Create the specific task manager
48.         task_manager =HotelAgentTaskManager(agent=agent_instance)
50. # Define Agent Card
51.         port =int(os.getenv("PORT","8003"))# Default port 8003
52.         host = os.getenv("HOST","localhost")
53.         listen_host ="0.0.0.0"
55.         agent_card =AgentCard(
56.             name="Hotel Search Agent (A2A)",
57.             description="Provides hotel information based on location, dates, and guests.",
58.             url=f"http://{host}:{port}/",
59.             version="1.0.0",
60.             defaultInputModes=["text"],
61.             defaultOutputModes=["text"],
62.             capabilities={"streaming":False},
63.             skills=[
64. {
65. "id":"search_hotels",
66. "name":"Search Hotels",
67. "description":"Searches for hotels based on location, check-in/out dates, and number of guests.",
68. "tags":["hotels","travel","accommodation"],
69. "examples":["Find hotels in London from July 1st to July 5th for 2 adults"]
70. }
71. ]
72. )
74. # Create the A2AServer instance WITHOUT endpoint parameter
75.         a2a_server = A2AServer(
76.             agent_card=agent_card,
77.             task_manager=task_manager,
78.             host=listen_host,
79.             port=port
80. )
82.         config = uvicorn.Config(
83.             app=a2a_server.app,# Pass the Starlette app from A2AServer
84.             host=listen_host,
85.             port=port,
86.             log_level="info"
87. )

5.3 让我们启动酒店搜索应用程序（Langchain）作为调用 MCP 服务器的入口点

步骤 6：使用 A2A 协议实现主机代理作为代理之间的协调器

行程规划器是上述旅行规划的核心组成部分，使用航班和酒店服务之间的 A2A 协议。

1. ├── itinerary_planner/# Travel Planner Host Agent (Agent 3)
2. │├── __init__.py
3. │├── a2a/# A2A client implementations
4. ││├── __init__.py
5. ││└── a2a_client.py            # Clients for flight and hotel agents
6. │├── a2a_agent_card.json          # Agent capabilities declaration
7. │├── event_log.py                 # Event logging utilities
8. │├── itinerary_agent.py           # Main planner implementation
9. │├── itinerary_server.py          # FastAPI server
10. │├── run_all.py                   # Script to run all components
11. │├──static/# Static files
12. ││└──.well-known/# Agent discovery directory
13. ││└── agent.json           # Standardized agent discovery file
14. │└── streamlit_ui.py              # Main user interface

6.1 使用航班和酒店 API URL 实现 A2A 协议

• 包含与其他服务通信的客户端代码
• 实现 Agent-to-Agent 协议
• 包含用于调用航班和酒店搜索服务的模块

1. # Base URLs for the A2A compliant agent APIs
2. FLIGHT_SEARCH_API_URL = os.getenv("FLIGHT_SEARCH_API_URL","http://localhost:8000")
3. HOTEL_SEARCH_API_URL = os.getenv("HOTEL_SEARCH_API_URL","http://localhost:8003")
5. class A2AClientBase:
6. """Base client for communicating with A2A-compliant agents via the root endpoint."""
9. asyncdef send_a2a_task(self, user_message: str, task_id:Optional[str]=None, agent_type: str ="generic")->Dict[str,Any]:
10. ...
11. ....
12. # Construct the JSON-RPC payload with the A2A method and corrected params structure
13.         payload ={
14. "jsonrpc":"2.0",
15. "method":"tasks/send",
16. "params":{
17. "id": task_id,
18. "taskId": task_id,
19. "message":{
20. "role":"user",
21. "parts":[
22. {"type":"text","text": user_message}
23. ]
24. }
25. },
26. "id": task_id 
27. }

6.2 行程规划器代理卡JSON 元数据文件，描述代理的功能、端点、身份验证要求和技能。用于 A2A 协议中的服务发现

1. {
2. "name":"Travel Itinerary Planner",
3. "displayName":"Travel Itinerary Planner",
4. "description":"An agent that coordinates flight and hotel information to create comprehensive travel itineraries",
5. "version":"1.0.0",
6. "contact":"code.aicloudlab@gmail.com",
7. "endpointUrl":"http://localhost:8005",
8. "authentication":{
9. "type":"none"
10. },
11. "capabilities":[
12. "streaming"
13. ],
14. "skills":[
15. {
16. "name":"createItinerary",
17. "description":"Create a comprehensive travel itinerary including flights and accommodations",
18. "inputs":[
19. {
20. "name":"origin",
21. "type":"string",
22. "description":"Origin city or airport code"
23. },
24. {
25. "name":"destination",
26. "type":"string",
27. "description":"Destination city or area"
28. },
29. {
30. "name":"departureDate",
31. "type":"string",
32. "description":"Departure date in YYYY-MM-DD format"
33. },
34. {
35. "name":"returnDate",
36. "type":"string",
37. "description":"Return date in YYYY-MM-DD format (optional)"
38. },
39. {
40. "name":"travelers",
41. "type":"integer",
42. "description":"Number of travelers"
43. },
44. {
45. "name":"preferences",
46. "type":"object",
47. "description":"Additional preferences like budget, hotel amenities, etc."
48. }
49. ],
50. "outputs":[
51. {
52. "name":"itinerary",
53. "type":"object",
54. "description":"Complete travel itinerary with flights, hotels, and schedule"
55. }
56. ]
57. }
58. ]
59. }

6.3 使用 Google-GenAI SDK 的行程代理

为了简化演示，我们使用 GenAI SDK（可以使用 ADK、CrewAI 或其他框架）。

行程代理充当系统的中央主机代理，负责协调与航班和酒店搜索服务的通信，并使用语言模型解析自然语言请求。

1. import google.generativeai as genai # Use direct SDK
2. ..
3. ..
4. from itinerary_planner.a2a.a2a_client importFlightSearchClient,HotelSearchClient
6. # Configure the Google Generative AI SDK
7. genai.configure(api_key=api_key)
9. classItineraryPlanner:
10. """A planner that coordinates between flight and hotel search agents to create itineraries using the google.generativeai SDK."""
12. def __init__(self):
13. """Initialize the itinerary planner."""
14.         logger.info("Initializing Itinerary Planner with google.generativeai SDK")
15. self.flight_client =FlightSearchClient()
16. self.hotel_client =HotelSearchClient()
18. # Create the Gemini model instance using the SDK
19. self.model = genai.GenerativeModel(
20.             model_name="gemini-2.0-flash",
21. )
22. ..
23. ..

6.4 行程服务器——FastAPI 服务器为行程规划器公开端点，处理传入的 HTTP 请求并将请求路由到行程代理

1. from fastapi importFastAPI,HTTPException,Request
3. from itinerary_planner.itinerary_agent importItineraryPlanner
5. @app.post("/v1/tasks/send")
6. asyncdef send_task(request:TaskRequest):
7. """Handle A2A tasks/send requests."""
8. global planner
10. ifnot planner:
11. raiseHTTPException(status_code=503, detail="Planner not initialized")
13. try:
14.         task_id = request.taskId
16. # Extract the message from the user
17.         user_message =None
18. for part in request.message.get("parts",[]):
19. if"text"in part:
20.                 user_message = part["text"]
21. break
23. ifnot user_message:
24. raiseHTTPException(status_code=400, detail="No text message found in request")
26. # Generate an itinerary based on the query
27.         itinerary =await planner.create_itinerary(user_message)
29. # Create the A2A response
30.         response ={
31. "task":{
32. "taskId": task_id,
33. "state":"completed",
34. "messages":[
35. {
36. "role":"user",
37. "parts":[{"text": user_message}]
38. },
39. {
40. "role":"agent",
41. "parts":[{"text": itinerary}]
42. }
43. ],
44. "artifacts":[]
45. }
46. }
48. return response

6.5 Streamlit_ui使用 Streamlit 构建的用户界面，提供旅行计划表格并以用户友好的格式显示结果

1. ...
2. ...
3. # API endpoint
4. API_URL ="http://localhost:8005/v1/tasks/send"
6. def generate_itinerary(query: str):
7. """Send a query to the itinerary planner API."""
8. try:
9.         task_id ="task-"+ datetime.now().strftime("%Y%m%d%H%M%S")
11.         payload ={
12. "taskId": task_id,
13. "message":{
14. "role":"user",
15. "parts":[
16. {
17. "text": query
18. }
19. ]
20. }
21. }
23. # Log the user query and the request to the event log
24.         log_user_query(query)
25.         log_itinerary_request(payload)
27.         response = requests.post(
28.             API_URL,
29.             json=payload,
30.             headers={"Content-Type":"application/json"}
31. )
32.         response.raise_for_status()
34.         result = response.json()
36. # Extract the agent's response message
37.         agent_message =None
38. for message in result.get("task",{}).get("messages",[]):
39. if message.get("role")=="agent":
40. for part in message.get("parts",[]):
41. if"text"in part:
42.                         agent_message = part["text"]
43. break
44. if agent_message:
45. break
46. ..
47. ..
48. ...

步骤 7：最终演示

在每个终端中，我们启动服务器代理，如下所示，正如我们在下面的演示中看到的那样

1. # Start Flight Search Agent - 1 Port 8000 
2. python -m flight_search_app.main
4. # Start Hotel Search Agent - 2 Port 8003
5. python -m hotel_search_app.langchain_server
7. # Start Itinerary Host Agent - Port 8005 
8. python -m itinerary_planner.itinerary_server
10. # Start frontend UI - Port 8501
11. streamlit run itinerary_planner/streamlit_ui.py

带有主机代理发起的任务ID的航班搜索日志

包含由主机代理发起的任务的酒店搜索日志

行程规划师——负责所有请求/响应的接待代理

代理事件日志

此演示实现了 Google A2A 协议的核心原则，使代理能够以结构化、可互操作的方式进行通信。上述演示中已完整实现了这些组件。

• AgentCard - 所有代理均公开 .well-known/agent.json 文件以供发现。
• A2A 服务器 - 每个代理都作为 A2A 服务器运行：flightsearchapp、hotelsearchapp 和 itinerary_planner
• A2A 客户端 - itinerary_planner 包含专用于航班和酒店代理的 A2A 客户端。
• 任务管理 - 每个请求/响应都被建模为一个 A2A 任务，并具有已提交、正在处理和已完成等状态。
• 消息结构 - 使用标准 JSON-RPC 格式，包含角色（用户/代理）和部分（主要为 TextPart）。

以下组件在我们的演示中尚未实现，但可以扩展为企业级代理。

• Streaming (SSE) -A2A 支持服务器发送事件用于长时间运行的任务，但我们的演示使用了简单的请求/响应，耗时不到 3-5 秒。
• 推送通知 - 尚未使用 Web-hook 更新机制。
• 复杂部分 - 仅使用 TextPart。可以添加对 DataPart、FilePart 等的支持，以实现更丰富的负载。
• 高级发现 - 已实现基本的 .well-known/agent.json 文件，但未实现高级身份验证、JWKS 或授权流程。

---

总结

本文探讨了如何在旅行规划场景中使用可复用的 A2A 组件、ADK、LangChain 和 MCP 构建功能齐全的多智能体系统。通过结合这些开源工具和框架，我们的智能体能够：

• 使用 A2A 动态地发现和调用彼此
• 通过 MCP 以模型友好的方式连接到外部 API
• 利用 ADK 和 LangChain 等现代框架
• 以清晰的任务生命周期和结构化结果进行异步通信

相同的原则可以扩展到更多领域，例如零售、客户服务自动化、运营工作流和 AI 辅助企业工具。

 如何系统的去学习大模型LLM ？

大模型时代，火爆出圈的LLM大模型让程序员们开始重新评估自己的本领。 “AI会取代那些行业？”“谁的饭碗又将不保了？”等问题热议不断。

事实上，抢你饭碗的不是AI，而是会利用AI的人。

继科大讯飞、阿里、华为等巨头公司发布AI产品后，很多中小企业也陆续进场！超高年薪，挖掘AI大模型人才！ 如今大厂老板们，也更倾向于会AI的人，普通程序员，还有应对的机会吗？

与其焦虑……

不如成为「掌握AI工具的技术人」，毕竟AI时代，谁先尝试，谁就能占得先机！

但是LLM相关的内容很多，现在网上的老课程老教材关于LLM又太少。所以现在小白入门就只能靠自学，学习成本和门槛很高。

基于此，我用做产品的心态来打磨这份大模型教程，深挖痛点并持续修改了近70次后，终于把整个AI大模型的学习门槛，降到了最低！

在这个版本当中：

第一您不需要具备任何算法和数学的基础
第二不要求准备高配置的电脑
第三不必懂Python等任何编程语言

您只需要听我讲，跟着我做即可，为了让学习的道路变得更简单，这份大模型教程已经给大家整理并打包，现在将这份 LLM大模型资料 分享出来：包括LLM大模型书籍、640套大模型行业报告、LLM大模型学习视频、LLM大模型学习路线、开源大模型学习教程等, 😝有需要的小伙伴，可以 扫描下方二维码领取🆓↓↓↓

​

一、LLM大模型经典书籍

AI大模型已经成为了当今科技领域的一大热点，那以下这些大模型书籍就是非常不错的学习资源。

二、640套LLM大模型报告合集

这套包含640份报告的合集，涵盖了大模型的理论研究、技术实现、行业应用等多个方面。无论您是科研人员、工程师，还是对AI大模型感兴趣的爱好者，这套报告合集都将为您提供宝贵的信息和启示。(几乎涵盖所有行业)

三、LLM大模型系列视频教程

四、LLM大模型开源教程（LLaLA/Meta/chatglm/chatgpt）

五、AI产品经理大模型教程

LLM大模型学习路线 ↓

阶段1：AI大模型时代的基础理解

• 目标：了解AI大模型的基本概念、发展历程和核心原理。

• 内容：

  • L1.1 人工智能简述与大模型起源
  • L1.2 大模型与通用人工智能
  • L1.3 GPT模型的发展历程
  • L1.4 模型工程
  • L1.4.1 知识大模型
  • L1.4.2 生产大模型
  • L1.4.3 模型工程方法论
  • L1.4.4 模型工程实践
  • L1.5 GPT应用案例

阶段2：AI大模型API应用开发工程

• 目标：掌握AI大模型API的使用和开发，以及相关的编程技能。

• 内容：

  • L2.1 API接口
  • L2.1.1 OpenAI API接口
  • L2.1.2 Python接口接入
  • L2.1.3 BOT工具类框架
  • L2.1.4 代码示例
  • L2.2 Prompt框架
  • L2.3 流水线工程
  • L2.4 总结与展望

阶段3：AI大模型应用架构实践

• 目标：深入理解AI大模型的应用架构，并能够进行私有化部署。

• 内容：

  • L3.1 Agent模型框架
  • L3.2 MetaGPT
  • L3.3 ChatGLM
  • L3.4 LLAMA
  • L3.5 其他大模型介绍

阶段4：AI大模型私有化部署

• 目标：掌握多种AI大模型的私有化部署，包括多模态和特定领域模型。

• 内容：

  • L4.1 模型私有化部署概述
  • L4.2 模型私有化部署的关键技术
  • L4.3 模型私有化部署的实施步骤
  • L4.4 模型私有化部署的应用场景

这份 LLM大模型资料 包括LLM大模型书籍、640套大模型行业报告、LLM大模型学习视频、LLM大模型学习路线、开源大模型学习教程等, 😝有需要的小伙伴，可以 扫描下方二维码领取🆓↓↓↓

​