本文为Java程序员提供转型AI大模型开发的实用建议，帮助读者快速掌握大模型开发的核心技能。文章从市场趋势、岗位需求、学习路线出发，详细介绍了如何从基础Python调用大模型API开始，逐步深入学习RAG、LangChain、LangGraph等框架，最终实现工程化思维与模型微调。适合希望利用自身Java背景进入AI领域的小白和程序员参考学习。

开个好头

AI 爆发到现在已经好几年了，但是依旧还有一些老一辈艺术家在坚持古法编程，也不知道是因为什么不去接受 AI 带来的生产率提高好让你早点下班。

但是也有一些朋友已经提前走上了转型的道路，还是那句话，时代的轮子来了，你不跑你只能被当成养料。

但是如何转型？？？一脸懵啊，看了那么多各家培训机构吹的牛逼，动不动转型就是 2、30k，我看了我也眼红，但是不知道路线，咋整？那么看完这篇文章可能对你是有一点点帮助了。

到目前为止，市面上的岗位已经慢慢的变得稳定，从开始的 Prompt 工程师，到后来的 RAG 工程师，再到现在的 Agent 开发工程师，说明大模型发展的速度也是越来越快。最开始让你会写 Prompt 再到现在让你必须得会构建 Agent，个人需要掌握的能力也是要求越来越高。不过薪资也是足够吸引人，你会 AI 和不会 AI 带来的薪资完全是两码事，而且据我了解，现在招人的简介中多多少少都会写一句会 AI 的优先。

说到正事

从21 年开始，市面上的 crud boy 就已经趋近于饱和了，在这之后找工作的人应该多多少少有点感触。但是学 Java 的人他具备非常良好的后端业务思维，而且少部分人是具备整体的架构思维。什么意思？就是他知道一个接口我应该让前端给我什么样的参数，参数规范是什么，走到后端应该落哪个表，落完表后对整个业务系统的影响是什么。

那么这个思维，在 AI 开发中就显得尤为重要。所谓的 vibe coding，无非就两种模式，一种是 Spec 工程计划模式，另一种就是纯自然语言交互模式，当你具备了工程化的思维时，就能很好的指挥 AI 开始干活了。

然后我们再说，大模型开发该怎么学？到目前我了解到的岗位一个是算法工程师。顾名思义，这个岗位属于是顶尖那批人，我们是用轮子的，他们是造轮子的。另一个就稍微简单，AI 应用开发工程师，属于是在造好的轮子上拼凑汽车。

前者我也不太了解，因为我确实不会那些技术，什么大模型原理，moe 架构，我一个都不会。

后者是 AI 应用工程师，这一块我们要学起来就稍显简单，虽然东西也一样的多，但是上手之后进展巨快。但是怎么学？问 der 包？问 ds？别费那时间，直接找培训机构的学习路线图。我不是让你报班，我也不打广告，但是这是上班摸鱼自学的最快方式。

举个例子，看一个某马的学习路线（截个图）：

上面的路线清清楚楚，里面涉及到的核心算法也没有想的那么复杂，所以想的那么多，不如每天摸鱼看看文档。

直接开始

首先，你会 Java，那么你学 Python 的基础就一定非常快；什么玩意儿 for 循环，while，if-else 都是小问题。并发编程也只是跟 Java 的写法不一样而已，核心原理一通百通，但是刚开始写 Python 代码肯定会不适应，怎么办？让 AI 写。

目前主流的两种大模型协议，各大厂商都在遵守，一个是 OpenAI 协议，一个是Anthropic协议，没办法，谁让人家牛逼，能站在领先的角度。

OpenAI：常见的url 中就比如 /v1 地址，比如https://token-plan-cn.xiaomimimo.com/v1Anthropic：后缀包含anthropic，比如https://token-plan-cn.xiaomimimo.com/anthropic

你不用理会这两种有什么区别，只需要知道能通过这种方式去调用就可以。

而且现在有非常多的大模型可以免费白嫖 api，再不济充 10 块钱给 ds 也能用用；所以你的第一步就是先学会用 python 调用大模型 api，知道里面的返回结果分别是什么意思。

比如这段代码：

import requests

# 配置
base_url = "https://token-plan-cn.xiaomimimo.com/v1"
api_key = "tp-xxxx"

# 请求
url = f"{base_url}/chat/completions"
headers = {
    "api-key": api_key,
    "Content-Type": "application/json"
}
data = {
    "model": "mimo-v2.5-pro",
    "messages": [
        {
            "role": "system",
            "content": "You are MiMo, an AI assistant developed by Xiaomi. Today is date: Tuesday, December 16, 2025. Your knowledge cutoff date is December 2024."
        },
        {
            "role": "user",
            "content": "please introduce yourself"
        }
    ],
    "max_completion_tokens": 1024
}

response = requests.post(url, headers=headers, json=data)

# 输出
if response.status_code == 200:
    result = response.json()
    print("✅ 回答：", result["choices"][0]["message"]["content"])
else:
    print("❌ 失败：", response.status_code, response.text)

不出意外你能得到这段结果：

{“id”:“f4b89f8447d942de9a2b64c76cc73107”,“choices”:[{“finish_reason”:“stop”,“index”:0,“message”:{“content”:“Hi there! I’m MiMo, your friendly AI assistant from Xiaomi. I’m here to help answer questions, brainstorm ideas, or just chat—whether it’s about tech, daily life, or random curiosities. I aim to be helpful, creative, and always supportive. What can I do for you today?”,“role”:“assistant”,“tool_calls”:null,“reasoning_content”:“Okay, the user just asked me to introduce myself. This is a straightforward request with no hidden agenda—probably a new user testing the waters or just being friendly. As MiMo from Xiaomi, I need to keep it warm, positive, and helpful to build rapport, while highlighting my capabilities without overwhelming them. Key points: Start with a greeting, state who I am and my purpose, list core strengths in a casual way, end with an open invitation to chat. Avoid any technical jargon or negativity; stick to engaging, supportive tone per the primary principle.”}}],“created”:1781079350,“model”:“mimo-v2.5-pro”,“object”:“chat.completion”,“usage”:{“completion_tokens”:181,“prompt_tokens”:55,“total_tokens”:236,“completion_tokens_details”:{“reasoning_tokens”:113},“prompt_tokens_details”:{}}}

其中的一些关键参数了解一下：

• completion_tokens：输出 token
• prompt_tokens：输入 token
• total_tokens：token 合计
• message： 模型的返回结果

只要你看到这些数据，那么恭喜你，你已经入门了，可以去找 20k 的工作了

走到这一步，你就可以开始发散你的思维了，做一个 demo 出来，怎么做？让 AI 给你画个前端，对接一下你的后端，不管是 python 还是 Java，对接你用的大模型地址和 apikey，然后聊天框发起访问，拿到结果，渲染界面，demo 就算完成；

然后做什么？

走完上面的流程，开始研究 rag，rag 要学什么东西才算完整，可以去看我的上一篇文章中有详细的描述，这里只讲一些基础；

什么是 rag？rag 是一个系统，他通过在你与大模型对话的过程中，通过检索数据库来增强你给大模型的上下文，让大模型能根据你的私有知识回答问题。

从这里开始，我建议你全部主攻 python 语言来开发，Java 暂时放一边。python 中有成熟的 rag 框架，比如 llamaindex，Langchain 等等。不过还是建议你从 0 开始，慢慢实现一个 rag 流程；

你需要准备一些文档，比如任何一本电子书，你的工作笔记，你的情书都可以，将它们整理成比较简单的数据结构。然后将数据塞进 Chroma、Faiss、Milvus 等等数据库，在然后，就可以开始借助你刚刚做的那个 demo，我们就可以将它继续完善成一个带 rag 的demo 了；

你要实现查询改写，就是将你的原始问题，通过提示词让大模型给出不同的问题出来，因为你的原始问题可能并不能很好的检索到文档，这时候就得以量取胜。

然后就把你检索出的结果通过提示词拼凑起来交给大模型，告诉大模型结合你的上下文一起给出回答；

这时候你的 demo 就算是完成了对 rag 的整合，你也已经具备了rag 工程师的水准。

import chromadb
import requests

# ===================== 1. 配置信息（你的密钥）=====================
MIMO_API_KEY = "tp-xxxx"
MIMO_BASE_URL = "https://token-plan-cn.xiaomimimo.com/v1"

# ===================== 2. 初始化 Chroma 向量库 =====================
# 本地持久化 Chroma（会自动创建文件夹）
client = chromadb.PersistentClient(path="./chroma_db")

# 创建/获取集合
collection = client.get_or_create_collection(name="demo_knowledge_base")

# 先插入几条演示数据（真实场景是你提前导入的文档/知识库）
demo_docs = [
    "小米MiMo是由小米公司开发的AI助手，知识截止到2024年12月。",
    "Chroma是一个轻量级开源向量数据库，专门用于存储和检索文本向量。",
    "RAG = 检索增强生成，先检索知识库，再给大模型生成回答。",
    "大模型调用需要API-KEY认证，请求格式遵循OpenAI规范。"
]

# 给 Chroma 添加数据
collection.add(
    documents=demo_docs,
    ids=[f"id{i}" for i in range(len(demo_docs))]
)

# ===================== 3. 核心 RAG 流程函数 =====================
def rag_chat(user_question):
    """
    完整 RAG 流程：
    1. 接收用户问题
    2. 从 Chroma 检索相关知识
    3. 拼接提示词
    4. 调用 MiMo 大模型
    5. 返回最终回答
    """
    print(f"🧑 用户问题：{user_question}/n")

    # -------------------- 步骤1：从 Chroma 检索相关文档 --------------------
    results = collection.query(
        query_texts=[user_question],
        n_results=2  # 取最相关的2条
    )
    retrieved_docs = results["documents"][0]
    print("📚 检索到知识库内容：")
    for idx, doc in enumerate(retrieved_docs):
        print(f"{idx+1}. {doc}")

    # -------------------- 步骤2：拼接提示词 --------------------
    context_str = "/n".join(retrieved_docs)
    prompt = f"""
你是小米MiMo助手，请根据下面的知识库内容回答用户问题。
如果知识库没有相关信息，就说“根据现有知识无法回答”。

知识库内容：
{context_str}

用户问题：{user_question}
请直接给出简洁回答。
    """

    # -------------------- 步骤3：调用 MiMo 大模型 --------------------
    url = f"{MIMO_BASE_URL}/chat/completions"
    headers = {
        "api-key": MIMO_API_KEY,
        "Content-Type": "application/json"
    }
    data = {
        "model": "mimo-v2.5-pro",
        "messages": [
            {"role": "system", "content": "你是MiMo，由小米开发的AI助手。"},
            {"role": "user", "content": prompt}
        ],
        "max_completion_tokens": 1024
    }

    response = requests.post(url, headers=headers, json=data)
    if response.status_code != 200:
        return f"请求失败：{response.status_code} {response.text}"

    # -------------------- 步骤4：解析并返回回答 --------------------
    answer = response.json()["choices"][0]["message"]["content"]
    return answer

# ===================== 4. 运行测试 =====================
if __name__ == "__main__":
    # 测试问题1
    question = "什么是RAG？"
    final_answer = rag_chat(question)
    
    print("/n🤖 MiMo 最终回答：/n", final_answer)

经历了简单 rag 之后，这时候你会了解到知识图谱，知识图谱在原本简单的 rag 之上，增强了发散的能力，为每一个节点增加了图检索的功能，这会让你的 rag 变得更加强大。

继续升级

这时候，你就要开始学一些主流的框架了，比如 Langchain，langgraph。

如果你学过 Langchain4j，那么 langchain 对你来说就是小 case，如果没学过，那也不影响。

你就要开始用 Langchain 开始创建出你的第一个 Agent，这会直接让你前面做的 demo 代码完完全全的简化，你只需要配置一些简单的 apikey，url 以及 Id 就能直接调通大模型的响应。

当你学会了基础调用后，你就会了解到什么是 tool，tool 怎么在实际的调用中是用。什么又是长短期记忆，在我们整个业务系统中起什么作用。然后就是会话摘要，如何借助中间件来对我们的上下文做管理。

到这时，就可以收手了，差不多可以了，Langchain 的核心也就这些，可以开始花时间研究 langgraph 了；

import requests
from langchain.tools import tool
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough
from langchain_chroma import Chroma


from langchain_core.documents import Document
from langchain_core.embeddings import Embeddings
from langchain.agents import create_openai_tools_agent, AgentExecutor
from langchain_core.memory import BaseMemory
from langchain.memory import ConversationSummaryMemory, ConversationBufferMemory
from typing import List, Dict

# ===================== 【1】配置你的 MiMo 大模型 =====================

MIMO_API_KEY = "tp-xxx"
MIMO_BASE_URL = "https://token-plan-cn.xiaomimimo.com/v1"
MODEL_NAME = "mimo-v2.5-pro"

# ------------------------- 自定义 MiMo 模型（适配 LangChain 1.x）-------------------------

class MiMoChatModel:
    def __init__(self, api_key, base_url, model):
        self.api_key = api_key
        self.base_url = base_url
        self.model = model

    def bind_tools(self, tools):
        self.tools = tools
        return self
    
    def invoke(self, input_data):
        headers = {"api-key": self.api_key, "Content-Type": "application/json"}
        
        # 处理 Agent 消息格式
        messages = input_data.get("messages", [])
        
        data = {
            "model": self.model,
            "messages": messages,
            "max_completion_tokens": 1024
        }
    
        resp = requests.post(f"{self.base_url}/chat/completions", headers=headers, json=data)
        resp.raise_for_status()
        return resp.json()["choices"][0]["message"]["content"]

# 初始化模型

llm = MiMoChatModel(MIMO_API_KEY, MIMO_BASE_URL, MODEL_NAME)

# ===================== 【2】自定义工具（Tool）=====================

@tool
def search_weather(city: str) -> str:
    """查询指定城市的天气，参数 city 是城市名"""
    return f"{city} 今天天气晴朗，温度 25℃，微风。"

@tool
def calculate(a: int, b: int, op: str) -> str:
    """简单计算器，a b 为数字，op 为 + - * /"""
    if op == "+": return str(a + b)
    if op == "-": return str(a - b)
    if op == "*": return str(a * b)
    if op == "/": return str(a / b if b !=0 else "错误")
    return "不支持的操作"

tools = [search_weather, calculate]

# ===================== 【3】RAG 向量库（Chroma）=====================

class DummyEmb(Embeddings):
    def embed_documents(self, texts):
        return [[0.1]*5 for _ in texts]
    def embed_query(self, text):
        return [0.1]*5

vector_db = Chroma(
    collection_name="full_rag_demo",
    embedding_function=DummyEmb(),
    persist_directory="./chroma_agent_demo"
)

# 插入知识库

vector_db.add_documents([
    Document(page_content="MiMo 是小米公司开发的AI助手，知识截止到2024年12月。"),
    Document(page_content="RAG = 检索增强生成，先检索知识库再回答问题。"),
    Document(page_content="LangChain 1.x 使用 LCEL 语法，支持 Agent + Memory + RAG 一体化。")
])

# RAG 检索工具

@tool
def rag_search(query: str) -> str:
    """从公司知识库检索信息，用于回答内部知识问题"""
    retriever = vector_db.as_retriever(search_kwargs={"k":2})
    docs = retriever.get_relevant_documents(query)
    return "/n".join([d.page_content for d in docs])

tools.append(rag_search)

# ===================== 【4】记忆 + 会话摘要（Memory）=====================

# 摘要记忆：自动总结历史，不会无限膨胀

memory = ConversationSummaryMemory(
    llm=llm,
    return_messages=True,
    memory_key="chat_history",
    output_key="output"
)

# ===================== 【5】创建 Agent（LangChain 1.x 标准）=====================

prompt = ChatPromptTemplate.from_messages([
    ("system", "你是强大的 MiMo 助手，能使用工具、记忆对话、检索知识库。"),
    MessagesPlaceholder(variable_name="chat_history"),
    ("user", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad"),
])

# 创建 Agent

agent = create_openai_tools_agent(llm, tools, prompt)
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    memory=memory,
    verbose=True,
    return_intermediate_steps=True
)

# ===================== 【6】测试全流程对话 =====================

if __name__ == "__main__":
    print("=" * 60)
    print("开始全功能对话（输入 exit 退出）")
    print("=" * 60)

    while True:
        user_input = input("/n你：")
        if user_input.lower() in ["exit", "quit"]:
            print("结束对话！")
            break
    
        result = agent_executor.invoke({"input": user_input})
        print("/n🤖 MiMo：", result["output"])
    
        # 查看自动生成的会话摘要
        print("/n📝 会话摘要：", memory.buffer)

langgraph 怎么学？搞懂什么是图，构成整个图的三要素：点，状态，边；

你把 langgraph 想象成一张巨大的蜘蛛网，上面每一个交叉处就是一个点，点与点之间存在不同的边。他们之间要相互工作，就必须有一个中央的状态管理。

如果 Langchain 是构建单一的 Agent，那么 langgraph 就是非常多不同的 Agent，通过一个状态（State）来管理；你不用关心这个 state 存储什么数据，他就是一个类，什么都能存。

from typing import TypedDict, Annotated
from langgraph.graph import StateGraph, END
import operator

# ====================== 1) State：状态（三要素之一） ======================

class AgentState(TypedDict):
    # 全局共享状态
    question: str
    context: str       # RAG 检索结果
    tool_result: str    # 工具调用结果
    answer: str         # 最终回答
    messages: Annotated[list, operator.add]  # 对话历史（自动合并）

# ====================== 2) Node：节点（三要素之二） ======================

def node_rag_retrieve(state: AgentState):
    """RAG 检索节点"""
    print("→ 执行 RAG 知识库检索")
    return {"context": "RAG 结果：LangGraph 三要素 = State、Node、Edge"}

def node_tool_call(state: AgentState):
    """工具调用节点（模拟计算器）"""
    print("→ 执行工具调用（计算器）")
    return {"tool_result": "计算结果：100 + 200 = 300"}

def node_llm_answer(state: AgentState):
    """大模型生成回答"""
    print("→ 大模型生成最终回答")
    answer = f"根据检索：{state['context']}/n根据工具：{state['tool_result']}"
    return {"answer": answer}

# ====================== 3) Edge：边 & 路由（三要素之三） ======================

def route_question(state: AgentState):
    """条件路由：决定走 RAG 还是 工具"""
    q = state["question"].lower()
    if "langgraph" in q:
        return "rag"
    elif "计算" in q or "多少" in q:
        return "tool"
    else:
        return "llm"

# ====================== 构建流程图 ======================

workflow = StateGraph(AgentState)

# 添加节点

workflow.add_node("rag_node", node_rag_retrieve)
workflow.add_node("tool_node", node_tool_call)
workflow.add_node("llm_node", node_llm_answer)

# 设置入口

workflow.set_entry_point("rag_node")

# 添加条件边

workflow.add_conditional_edges(
    "rag_node",
    route_question,
    {
        "rag": "rag_node",
        "tool": "tool_node",
        "llm": "llm_node"
    }
)

# 普通边

workflow.add_edge("tool_node", "llm_node")
workflow.add_edge("llm_node", END)

# 编译图

app = workflow.compile()

# ====================== 测试运行 ======================

if __name__ == "__main__":
    user_question = "LangGraph 三要素是什么？100+200 等于多少？"
    

    result = app.invoke({
        "question": user_question,
        "messages": [{"role": "user", "content": user_question}]
    })
    
    print("/n" + "="*50)
    print("最终回答：")
    print(result["answer"])

最终boss

恭喜你，学到这里，你已经能应付市面上的大部分工作了，那么剩下的进阶是什么呢？工程化的思维以及对模型的微调；

工程化的思维指的是，你能完美熟练的运用上方的各种技术，将它们融合，整理成一个大的系统进行对外暴露，这其中包括，token 计费系统，可观测平台，rag 召回率调优，大模型网关等等；

至于模型的微调，如果不是特定领域下，我是不建议你去微调的，微调后的模型能力可能并没有增强多少，反而可能降低；但是微调的作用也很明显：比如医疗场景生成病历，微调后的模型能对更多的专业医疗名词进行描述书写；

最后也是奉上一张学习路线图，祝你早日转行成为一名合格的 AI 摸鱼工程师

最后

2026 年一晃已经过半，AI 大模型的热潮不仅没有降温，反而持续升温！

金融行业用大模型做风控、医疗依靠 AI 解析影像，电商、制造、教育各行各业，都在把 AI 融入日常业务。曾经热闹的 “百模大战”，早就告别单纯比拼模型参数，正式进入落地应用时代。

现在企业疯狂紧缺一类人才：懂业务、懂 AI、能做出可上线项目的大模型开发工程师，岗位缺口大，薪资待遇十分可观。

风口再好，不如手握高薪 offer 实在。行情火热，普通人、程序员该怎样从零入门大模型，抓住这波机会？

今天整理好【2026 最新版】AI 大模型全套免费学习资源，覆盖零基础入门、项目实战、理论知识、大厂面试，从基础一路进阶。所有资料分类归档，没有多余杂料，无套路免费分享给想要入局 AI 赛道的程序员与零基础小白！

👇👇扫码免费领取全部内容👇👇

1、大模型系统化完整学习路线

2、大模型经典书籍&文档

3、AI 大模型最新行业研究报告

4、企业级实战项目 + 完整配套源码

5、大厂大模型面试真题汇总

6、这些资料真的有用吗？

这份资料由我和鲁为民博士(北京清华大学学士和美国加州理工学院博士)共同整理，现任上海殷泊信息科技CEO，其创立的MoPaaS云平台获Forrester全球’强劲表现者’认证，服务航天科工、国家电网等1000+企业，以第一作者在IEEE Transactions发表论文50+篇，获NASA JPL火星探测系统强化学习专利等35项中美专利。本套AI大模型课程由清华大学-加州理工双料博士、吴文俊人工智能奖得主鲁为民教授领衔研发。

资料内容涵盖了从入门到进阶的各类视频教程和实战项目，无论你是小白还是有些技术基础的技术人员，这份资料都绝对能帮助你提升薪资待遇，转行大模型岗位。

这份完整版的大模型 AI 学习资料已经上传CSDN，朋友们如果需要可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】