我很清楚对于那些完全不熟悉 VS Code、Git、Docker、FHIR 和其他工具的人来说，设置环境时会遇到一些困难。 所以我决定写这篇文章，详细介绍整个设置过程，以便大家能够轻松上手。
如果您能在本文最后留下评论，告诉我说明是否清楚，是否有遗漏，或者是否有其他您觉得有用的东西，我将不胜感激。
设置包括：
✅ VS Code – 代码编辑器
✅ Git – 版本控制系统
✅ Docker – 运行 IRIS for Health Community 的实例
✅ VS Code REST 客户端扩展程序 – 用于运行 FHIR API 查询
✅ Python – 用于编写基于 FHIR 的脚本
✅ Jupyter Notebook – 用于 AI 和 FHIR 任务
准备工作：确保您在系统上拥有管理员权限。
除了阅读本指南，您还可以按照视频中的步骤操作：
如果您是 Windows 系统（请注意：原文是YouTube视频，请跳转至EN原帖查看）
Interoperability on Python (IoP) 是一个概念验证项目，旨在展示与 Python 优先方式相结合时 InterSystems IRIS Interoperability Framework 的强大功能。IoP 利用Embedded Python（嵌入式 Python，InterSystems IRIS 的一个功能）使开发者能够用 Python 编写互操作性组件，从而可以与强大的 IRIS 平台无缝集成。本指南专为初学者编写，全面介绍了 IoP、其设置以及创建第一个互操作性组件的操作步骤。 阅读完本文，您将能够清楚地了解如何使用 IoP 构建可扩缩、基于 Python 的互操作性解决方案。
学习如何使用 LangGraph 设计结合了推理、矢量搜索和工具集成的可扩缩自主 AI 智能体。
让我们直面它吧 —“AI 智能体”听起来就像可以接管会议室的机器人。 实际上，它们是您得力的助手，可以简化复杂的工作流，消除重复性任务。 您可以把它们看作是聊天机器人的下一个进化阶段：它们不只是简单地等待提示；它们可以发起行动，协调多个步骤，并随时进行调整。
过去，打造一个“智能”系统意味着兼顾语言理解、代码生成、数据查找等各种不同的模型，然后将它们粘合在一起。 您的一半时间花在了集成上，另一半时间则花在了调试上。
智能体彻底颠覆了这一切。 它们将上下文、主动性和适应性融合在一个精心编排的流程中。 它们不仅实现了自动化，更是肩负使命的智者。 借助 LangGraph 之类的框架，我相信，组建一支自己的智能体团队实际上会很有趣。
LangGraph 是一种创新型框架，它彻底改变了我们构建涉及大语言模型 (LLM) 的复杂应用程序的方式。
想象一下，您正在指挥一支管弦乐队：每种乐器（或“节点”）都需要知道何时演奏，声音有多大，顺序如何。 这种情况下，LangGraph 就是您的指挥棒，为您提供以下内容：
无论您是在构建具有真实记忆的聊天机器人、交互式故事引擎，还是能够处理复杂问题的智能体团队，LangGraph 都可以将令人头疼的管道工程转变成简单明了、直观的状态机。
要开始使用 LangGraph，您需要进行基本的设置，通常包括安装 langgraph 和 langchain-openai 等必要的库。 然后，您可以定义图中的节点（任务）和边缘（连接），有效地实现短期记忆的检查点，并利用 Zep 满足更持久的记忆需求。
操作 LangGraph 时，请记住以下几点：
现在，我们已经介绍 LangGraph 的基础知识，我们来看一个实例。 为此，我们将开发一个用于提供客户支持的 AI 智能体。
这个智能体将接收电子邮件请求，分析电子邮件正文中的问题描述，然后确定请求的优先级和适当的主题/类别/部门。
系好安全带，我们开始吧！
首先，我们需要定义什么是“工具”。 可以把它看作是智能体的专属“助理”，使其能够与外部功能进行交互。
@tool 装饰器在这里必不可少。 LangChain 简化了自定义工具的创建，这意味着首先，定义一个 Python 函数，然后应用 @tool 装饰器。
为了进行说明，我们来创建第一个工具。 这个工具将帮助智能体根据电子邮件内容划分 IT 支持工单的优先级：
from langchain_core.tools import tool
@tool
def classify_priority(email_body: str) -> str:
"""Classify the priority of an IT support ticket based on email content."""
prompt = ChatPromptTemplate.from_template(
"""Analyze this IT support email and classify its priority as High, Medium, or Low.
High: System outages, security breaches, critical business functions down
Medium: Non-critical issues affecting productivity, software problems
Low: General questions, requests, minor issues
Email: {email}
Respond with only: High, Medium, or Low"""
)
chain = prompt | llm
response = chain.invoke({"email": email_body})
return response.content.strip()
太棒了！ 现在，我们有一个提示，指示 AI 接收电子邮件正文，对其进行分析，并将其优先级分为“高”、“中”或“低”。
就是这样！ 您刚刚编写了一个智能体可以调用的工具！
接下来，我们创建一个类似的工具来识别支持请求的主要主题（或类别）：
@tool
def identify_topic(email_body: str) -> str:
"""Identify the main topic/category of the IT support request."""
prompt = ChatPromptTemplate.from_template(
"""Analyze this IT support email and identify the main topic category.
Categories: password_reset, vpn, software_request, hardware, email, network, printer, other
Email: {email}
Respond with only the category name (lowercase with underscores)."""
)
chain = prompt | llm
response = chain.invoke({"email": email_body})
return response.content.strip()
现在，我们需要创建一个状态，在 LangGraph 中，这一小部分非常重要。
把它想象成图的中枢神经系统。 这就是节点之间的通信方式，就像优等生在课堂上传递纸条一样。
文档中显示：
“状态是表示应用程序当前快照的共享数据结构。”
在实践中呢？ 状态是在节点之间移动的结构化消息。 它将一个步骤的输出作为下一个步骤的输入。 基本上，它是将整个工作流粘合在一起的粘合剂。
因此，在构建图之前，我们必须先定义我们的状态结构。 本例中，我们的状态包括以下内容：
它简单明了，因此您可以像专业人士一样浏览图。
from typing import TypedDict
# Define the state structure
class TicketState(TypedDict):
email_body: str
priority: str
topic: str
# Initialize state
initial_state = TicketState(
email_body=email_body,
priority="",
topic=""
)
LangGraph 的基本要素包括节点和边缘。
为了掌握边缘的功能，我们来看一个消息传递应用程序的简单类比：
当用户选择一个聊天主题来发送消息时，会有效地创建一个边缘，将他们与另一个用户连接在一起。 与 LangGraph 状态的结构化模式类似，每次交互（无论是发送文本、语音还是视频消息）都遵循预定义的顺序。 它确保了沿边缘传递的数据的一致性和可解释性。
不同于事件驱动型应用程序的动态特性，LangGraph 采用在整个执行过程中保持一致的静态模式。 它简化了节点之间的通信，使开发者可以依赖稳定的状态格式，从而确保无缝的边缘通信。
可以将 LangGraph 中的流工程理解为设计一个状态机。 在这个情境中，每个节点代表一个不同的状态或处理步骤，而边缘定义了这些状态之间的转换。 这种方式对想要在 AI 的确定性任务序列与动态决策能力之间取得平衡的开发者特别有用。 我们来使用前面定义的 TicketState 类初始化 StateGraph，开始构建流程。
from langgraph.graph import StateGraph, START, END
workflow = StateGraph(TicketState)
节点添加：节点是基本要素，用于执行划分工单优先级或识别其主题等特定任务。
每个节点函数均接收当前状态，执行其操作，并返回一个字典以更新状态：
def classify_priority_node(state: TicketState) -> TicketState:
"""Node to classify ticket priority."""
priority = classify_priority.invoke({"email_body": state["email_body"]})
return {"priority": priority}
def identify_topic_node(state: TicketState) -> TicketState:
"""Node to identify ticket topic."""
topic = identify_topic.invoke({"email_body": state["email_body"]})
return {"topic": topic}
workflow.add_node("classify_priority", classify_priority_node)
workflow.add_node("identify_topic", identify_topic_node)
classify_priority_node 和 identify_topic_node 方法将更改 TicketState 并发送参数输入。
边缘创建：定义连接节点的边缘：
workflow.add_edge(START, "classify_priority")
workflow.add_edge("classify_priority", "identify_topic")
workflow.add_edge("identify_topic", END)
classify_priority 确定起点，而 identify_topic 确定到目前为止工作流的终点。
编译与执行：配置节点和边缘后，编译并执行该工作流。
graph = workflow.compile()
result = graph.invoke(initial_state)
太好了！ 您还可以生成 LangGraph 流的可视化表示。
graph.get_graph().draw_mermaid_png(output_file_path="graph.png")
如果将代码运行到此点，您就会看到一个与下面类似的图：
这幅图直观地显示了一次顺序执行：开始，然后划分优先级，接着确定主题，最后结束。
LangGraph 最强大的一个方面是它的灵活性，这让我们可以创建更复杂的流程和应用程序。 例如，我们可以修改工作流，使用以下行将 START 中的边缘添加到两个节点：
workflow.add_edge(START, "classify_priority")
workflow.add_edge(START, "identify_topic")
这一更改意味着智能体将同时执行 classify_priority 和 identify_topic。
LangGraph 中另一个非常有用的功能是能够使用条件边缘。 它们允许工作流根据对当前状态的评估进行分支，实现任务的动态路由。
我们来增强工作流。 我们将创建一个新工具，分析请求的内容、优先级和主题，以确定它是否为需要上报（例如，为人工团队提交工单）的高优先级问题。 如果不需要，将为用户生成一个自动响应。
@tool
def make_escalation_decision(email_body: str, priority: str, topic: str) -> str:
"""Decide whether to auto-respond or escalate to IT team."""
prompt = ChatPromptTemplate.from_template(
"""Based on this IT support ticket, decide whether to:
- "auto_respond": Send an automated response for simple/common or medium priority issues
- "escalate": Escalate to the IT team for complex/urgent issues
Email: {email}
Priority: {priority}
Topic: {topic}
Consider: High priority items usually require escalation, while complex technical issues necessitate human review.
Respond with only: auto_respond or escalate"""
)
chain = prompt | llm
response = chain.invoke({
"email": email_body,
"priority": priority,
"topic": topic
})
return response.content.strip()
此外，如果请求被确定为低优先级或中等优先级（导致“auto_respond”决策），我们将执行矢量搜索来检索历史回答。 然后，将使用此信息来生成适当的自动回答。 不过，这需要两个额外的工具：
@tool
def retrieve_examples(email_body: str) -> str:
"""Retrieve relevant examples from past responses based on email_body."""
try:
examples = iris.cls(__name__).Retrieve(email_body)
return examples if examples else "No relevant examples found."
except:
return "No relevant examples found."
@tool
def generate_reply(email_body: str, topic: str, examples: str) -> str:
"""Generate a suggested reply based on the email, topic, and RAG examples."""
prompt = ChatPromptTemplate.from_template(
"""Generate a professional IT support response based on:
Original Email: {email}
Topic Category: {topic}
Example Response: {examples}
Create a helpful, professional response that addresses the user's concern.
Keep it concise and actionable."""
)
chain = prompt | llm
response = chain.invoke({
"email": email_body,
"topic": topic,
"examples": examples
})
return response.content.strip()
现在，我们为这些新工具定义相应的节点：
def decision_node(state: TicketState) -> TicketState:
"""Node to decide on escalation or auto-response."""
decision = make_escalation_decision.invoke({
"email_body": state["email_body"],
"priority": state["priority"],
"topic": state["topic"]
})
return {"decision": decision}
def rag_node(state: TicketState) -> TicketState:
"""Node to retrieve relevant examples using RAG."""
examples = retrieve_examples.invoke({"email_body": state["email_body"]})
return {"rag_examples": examples}
def generate_reply_node(state: TicketState) -> TicketState:
"""Node to generate suggested reply."""
reply = generate_reply.invoke({
"email_body": state["email_body"],
"topic": state["topic"],
"examples": state["rag_examples"]
})
return {"suggested_reply": reply}
def execute_action_node(state: TicketState) -> TicketState:
"""Node to execute final action based on decision."""
if state["decision"] == "escalate":
action = f"🚨 ESCALATED TO IT TEAM\nPriority: {state['priority']}\nTopic: {state['topic']}\nTicket created in system."
print(f"[SYSTEM] Escalating ticket to IT team - Priority: {state['priority']}, Topic: {state['topic']}")
else:
action = f"✅ AUTO-RESPONSE SENT\nReply: {state['suggested_reply']}\nTicket logged for tracking."
print(f"[SYSTEM] Auto-response sent to user - Topic: {state['topic']}")
return {"final_action": action}
workflow.add_node("make_decision", decision_node)
workflow.add_node("rag", rag_node)
workflow.add_node("generate_reply", generate_reply_node)
workflow.add_node("execute_action", execute_action_node)
然后，条件边缘将使用 make_decision 节点的输出来定向流：
workflow.add_conditional_edges(
"make_decision",
lambda x: x.get("decision"),
{
"auto_respond": "rag",
"escalate": "execute_action"
}
)
如果 make_escalation_decision 工具（通过 decision_node）产生“auto_respond”，工作流将继续通过 RAG 节点（检索示例），然后是 generate_reply 节点（设计回答），最后是 execute_action 节点（记录 auto-response）。
相反，如果决策是“escalate”，流程将绕过 RAG 和生成步骤，直接转到 execute_action 来处理上报。 要添加剩余的标准边缘来完成图，请执行以下操作：
workflow.add_edge("rag", "generate_reply")
workflow.add_edge("generate_reply", "execute_action")
workflow.add_edge("execute_action", END)
数据集注释：对于此项目，我们用于支持检索增强生成 (RAG) 的数据集来自 Hugging Face 上的 Customer Support Tickets 数据集。 对该数据集进行了筛选，以便只包含分类为技术支持并限制为英语的条目。 它确保 RAG 系统只为技术支持任务检索高度相关的特定领域的示例。
此时，我们的图应当与下图类似：
当您使用一封电子邮件来执行此图，并导致高优先级分类和“escalate”决策时，您将看到以下响应：
.png)
同时，被分类为低优先级并导致“auto_respond”决策的请求将触发与下面类似的回复：
并不完全是。 有一些问题需要注意：
不过，大多数缺点都可以通过良好的规划、合适的工具和一点点思考加以控制。
LangGraph 将 AI 智能体从流行语变成实实在在的有效解决方案。 无论您是要自动执行客户支持，处理 IT 工单，还是构建自主应用程序，这个框架都让操作变得可行，甚至有趣。
您有任何问题或反馈吗？ 请说出来。 AI 革命需要像您这样的建设者。
在本节中，我们将探讨如何在 IRIS 中使用 Python 作为主要编程语言，在使用 Python 编写应用程序逻辑的同时仍能利用 IRIS 的强大功能。
我们先来介绍官方操作方式，即使用 irispython 解释器。
您可以使用 irispython 解释器直接在 IRIS 中运行 Python 代码。 这样，您可以编写 Python 代码，并在 IRIS 应用程序的运行环境中执行相应代码。
irispython 是位于 IRIS 安装目录 (<installation_directory>/bin/irispython) 下的 Python 解释器，用于在 IRIS 的运行环境中执行 Python 代码。
它的功能包括：
sys.path，以包含 IRIS Python 库和模块。
<installation_directory>/lib/python/iris_site.py 中的 site.py 文件执行。iris 模块，这是一个特殊模块，用于访问 IRIS 功能，例如实现任何 ObjectScript 类与 Python 的双向桥接。您可以通过命令行运行 irispython 解释器：
<installation_directory>/bin/irispython
我们来运行一个简单的示例：
# src/python/article/irispython_example.py
import requests
import iris
def run():
response = requests.get("https://2eb86668f7ab407989787c97ec6b24ba.api.mockbin.io/")
my_dict = response.json()
for key, value in my_dict.items():
print(f"{key}: {value}") # print message: Hello World
return my_dict
if __name__ == "__main__":
print(f"Iris version: {iris.cls('%SYSTEM.Version').GetVersion()}")
run()
您可以使用 irispython解释器运行此脚本：
<installation_directory>/bin/irispython src/python/article/irispython_example.py
您将看到如下输出：
Iris version: IRIS for UNIX (Ubuntu Server LTS for x86-64 Containers) 2025.1 (Build 223U) Tue Mar 11 2025 18:23:31 EDT
message: Hello World
此例展示了如何使用 irispython 解释器在 IRIS 的运行环境中执行 Python 代码。
irispython 中调试 Python 代码并不像在专用 Python 环境中那样简单直接。
irispython 中为 Python 代码搭建虚拟环境比较困难。
python 或 python3 的解释器，而 IRIS 中的情况并非如此。总的来说，使用 irispython 解释器让您既可以利用 Python 编写应用程序逻辑，又能利用 IRIS 的强大功能。 不过，这种方式也存在调试和虚拟环境搭建方面的限制。
在本节中，我们将探讨如何使用 WSGI（Web 服务器网关接口）在 IRIS 中运行 Python Web 应用程序。
WSGI 是 Web 服务器与 Python Web 应用程序或框架之间的标准接口。 利用 WSGI，您可以在 Web 服务器环境中运行 Python Web 应用程序。
IRIS 支持 WSGI，这意味着您可以在 IRIS 中使用内置的 WSGI 服务器运行 Python Web 应用程序。
要在 IRIS 中使用 WSGI，您需要创建 WSGI 应用程序，并向 IRIS Web 服务器注册此应用程序。
如需了解详情，请参阅官方文档。
有关完整模板，请参见此处：iris-flask-example。
uvicorn 或 gunicorn 复杂一些。总的来说，在 IRIS 中使用 WSGI 让您既可以利用 Python 构建功能强大的 Web 应用程序，又能利用 IRIS 的功能。
在本节中，我们将探讨如何使用 Python DB-API 与 IRIS 数据库进行交互。
Python DB-API 是 Python 中用于连接数据库的标准接口。 利用此接口，您可以执行 SQL 查询，并从数据库中检索结果。
您可以使用 pip 进行安装：
pip install intersystems-irispython
随后，您可以使用 DB-API 连接 IRIS 数据库并执行 SQL 查询。
它的使用方法与其他所有 Python DB-API 相同，示例如下：
# src/python/article/dbapi_example.py
import iris
def run():
# Connect to the IRIS database
# Open a connection to the server
args = {
'hostname':'127.0.0.1',
'port': 1972,
'namespace':'USER',
'username':'SuperUser',
'password':'SYS'
}
conn = iris.connect(**args)
# Create a cursor
cursor = conn.cursor()
# Execute a query
cursor.execute("SELECT 1")
# Fetch all results
results = cursor.fetchall()
for row in results:
print(row)
# Close the cursor and connection
cursor.close()
conn.close()
if __name__ == "__main__":
run()
您可以使用任何 Python 解释器运行此脚本：
python3 /irisdev/app/src/python/article/dbapi_example.py
您将看到如下输出：
(1,)
还提供社区版 DB-API，参见此处：intersystems-irispython-community。
该版本能更好地支持 SQLAlchemy、Django、langchain，以及其他使用 DB-API 的 Python 库。
如需了解详情，请参阅 补充部分。
总的来说，将 Python DB-API 与 IRIS 结合使用能够让您构建功能强大的应用程序，实现与数据库的无缝交互。
现在，我们已了解如何在 IRIS 中使用 Python，接下来我们将探讨如何将 Jupyter Notebooks 与 IRIS 结合使用。
Jupyter Notebooks 是交互式编写和执行 Python 代码的绝佳方式，并且可与 IRIS 结合使用，以充分利用 IRIS 的功能。
要在 IRIS 中使用 Jupyter Notebooks，您需要安装 notebook 和 ipykernel 这两个软件包：
pip install notebook ipykernel
然后，您可以创建新的 Jupyter Notebook 并选择 Python 3 内核。
您可以创建新的 Jupyter Notebook 并编写以下代码：
# src/python/article/my_notebook.ipynb
# Import the necessary modules
import iris
# Do the magic
iris.system.Version.GetVersion()
您可以使用 Jupyter Notebook 运行此 notebook：
jupyter notebook src/python/article/my_notebook.ipynb
总的来说，将 Jupyter Notebooks 与 IRIS 结合使用可以交互式编写和执行 Python 代码，同时利用 IRIS 的功能。 不过，设置起来存在一定的难度，特别是对于内核配置而言。
从本节开始，我们将探讨一些与在 IRIS 中使用 Python 相关的高级主题，例如远程调试 Python 代码、使用虚拟环境等。
以下大部分主题均未获得 InterSystems 的官方支持，但如果您要在 IRIS 中使用 Python，了解相关内容会提供很大的帮助。
irispython）在本节中，我们将探讨如何使用原生 Python 解释器代替 irispython 解释器。
这样一来，您可以直接使用虚拟环境，并使用您习惯的 Python 解释器。
要使用原生 Python 解释器，您需要在机器本地安装 IRIS，并需要安装 iris-embedded-python-wrapper 软件包。
您可以使用 pip 进行安装：
pip install iris-embedded-python-wrapper
接下来，您需要设置一些环境变量指向 IRIS 安装目录：
export IRISINSTALLDIR=<installation_directory>
export IRISUSERNAME=<username>
export IRISPASSWORD=<password>
export IRISNAMESPACE=<namespace>
然后，您可以使用您的原生 Python 解释器运行 Python 代码：
python3 src/python/article/irispython_example.py
# src/python/article/irispython_example.py
import requests
import iris
def run():
response = requests.get("https://2eb86668f7ab407989787c97ec6b24ba.api.mockbin.io/")
my_dict = response.json()
for key, value in my_dict.items():
print(f"{key}: {value}") # print message: Hello World
return my_dict
if __name__ == "__main__":
print(f"Iris version: {iris.cls('%SYSTEM.Version').GetVersion()}")
run()
如需了解详情，请参阅 iris-embedded-python-wrapper 文档。
pdb 或 ipdb）在 IRIS 中调试 Python 代码。iris-embedded-python-wrapper 软件包可能会比较复杂，特别是对于初学者来说。在本节中，我们将探讨 GitHub 上提供的社区版 DB-API。
您可以使用 pip 进行安装：
pip install sqlalchemy-iris
此代码将安装社区版 DB-API。
或使用特定版本：
pip install https://github.com/intersystems-community/intersystems-irispython/releases/download/3.9.3/intersystems_iris-3.9.3-py3-none-any.whl
然后，您可以使用 DB-API 连接 IRIS 数据库，并执行 SQL 查询或其他任何使用 DB-API 的 Python 代码，如 SQLAlchemy、Django、langchain、pandas 等。
它的使用方法与其他所有 Python DB-API 相同，示例如下：
# src/python/article/dbapi_community_example.py
import intersystems_iris.dbapi._DBAPI as dbapi
config = {
"hostname": "localhost",
"port": 1972,
"namespace": "USER",
"username": "_SYSTEM",
"password": "SYS",
}
with dbapi.connect(**config) as conn:
with conn.cursor() as cursor:
cursor.execute("select ? as one, 2 as two", 1) # second arg is parameter value
for row in cursor:
one, two = row
print(f"one: {one}")
print(f"two: {two}")
您可以使用任何 Python 解释器运行此脚本：
python3 /irisdev/app/src/python/article/dbapi_community_example.py
也可以使用 sqlalchemy：
from sqlalchemy import create_engine, text
COMMUNITY_DRIVER_URL = "iris://_SYSTEM:SYS@localhost:1972/USER"
OFFICIAL_DRIVER_URL = "iris+intersystems://_SYSTEM:SYS@localhost:1972/USER"
EMBEDDED_PYTHON_DRIVER_URL = "iris+emb:///USER"
def run(driver):
# Create an engine using the official driver
engine = create_engine(driver)
with engine.connect() as connection:
# Execute a query
result = connection.execute(text("SELECT 1 AS one, 2 AS two"))
for row in result:
print(f"one: {row.one}, two: {row.two}")
if __name__ == "__main__":
run(OFFICIAL_DRIVER_URL)
run(COMMUNITY_DRIVER_URL)
run(EMBEDDED_PYTHON_DRIVER_URL)
您可以使用任何 Python 解释器运行此脚本：
python3 /irisdev/app/src/python/article/dbapi_sqlalchemy_example.py
您将看到如下输出：
one: 1, two: 2
one: 1, two: 2
one: 1, two: 2
在本节中，我们将探讨如何在 IRIS 中调试 Python 代码。
默认情况下，无法在 IRIS 中调试 Python 代码（在包含语言标签或 %SYS.Python 的 objectscript 中），但可以通过社区解决方案在 IRIS 中调试 Python 代码。
先安装 IoP 基于 Python 的互操作性：
pip install iris-pex-embedded-python
iop --init
此代码将安装 IoP 和新的 ObjectScript 类，以便您可以在 IRIS 中调试 Python 代码。
然后，您可以使用 IOP.Wrapper 类包装 Python 代码并实现调试。
Class Article.DebuggingExample Extends %RegisteredObject
{
ClassMethod Run() As %Status
{
set myScript = ##class(IOP.Wrapper).Import("my_script", "/irisdev/app/src/python/article/", 55550) // Adjust the path to your module
Do myScript.run()
Quit $$$OK
}
}
然后，向 launch.json 文件添加以下配置，将 VsCode 配置为使用 IoP 调试器：
{
"version": "0.2.0",
"configurations": [
{
"name": "Python in IRIS",
"type": "python",
"request": "attach",
"port": 55550,
"host": "localhost",
"pathMappings": [
{
"localRoot": "${workspaceFolder}/src/python/article",
"remoteRoot": "/irisdev/app/src/python/article"
}
]
}
]
}
现在，您可以运行用于导入 Python 模块的 ObjectScript 代码，然后将 VsCode 中的调试器关联到端口 55550。
您可以使用以下命令运行此脚本：
iris session iris -U IRISAPP '##class(Article.DebuggingExample).Run()'
然后，您可以在 Python 代码中设置断点，调试器将在这些断点处停止执行，以便您检查变量并单步执行代码。
远程调试实际运作视频（针对 IoP，但原理是相同的）：
Python 代码中还提供回溯信息，这对调试非常有用。
启用回溯时：
禁用回溯时：
总的来说，在 IRIS 中调试 Python 代码可以通过 IoP 社区解决方案来实现，借助该解决方案，您可以使用 Python 调试器调试在 IRIS 中运行的 Python 代码。 不过，此解决方案需要执行一些设置操作，并可能不像官方解决方案一样稳定。
在本节中，我们将探讨 IoP（基于 Python 的互操作性）解决方案，利用该解决方案，您可以使用 Python 优先的方式在 IRIS 中运行 Python 代码。
我开发这个解决方案已经有一段时间了，可以说它是我的心血之作，该解决方案尝试解决或改善我们在本系列文章中提到的所有问题。
IoP 的要点：
要详细了解 IoP，您可以查阅官方文档。
然后，您可以阅读以下文章详细了解 IoP：
🐍❤️如您所见，通过 IoP 这一功能强大的方法，我们可以将 Python 与 IRIS 相集成，从而可以更轻松地开发和调试应用程序。
您无需继续使用 irispython，也不必手动设置 sys.path，而是可以使用虚拟环境，并且可以调试在 IRIS 中运行的 Python 代码。
希望大家喜欢这一系列关于在 IRIS 中使用 Python 的文章。
如果您对这一系列的文章有任何疑问或反馈，请随时联系我。
祝您在 IRIS 中使用 Python 时一切顺利！
您知道当您拿到验血结果时一切看起来都像天书的那种感觉吗？ 这就是 FHIRInsight 要解决的问题。 它最初的理念是，医疗数据不应该令人恐惧或困惑 – 它应该是我们所有人都能使用的东西。 验血是健康检查中十分常见的检查，但说实话，大多数人都很难理解它们，有时甚至对不擅长实验室工作的医务人员来说也是如此。 FHIRInsight 希望整个过程能够变得更简单，信息更富有实用价值。
这一切都始于一个简单而有力的问题：
“为什么验血结果仍然很难读懂 — 有时甚至对医生来说也是如此？”
如果您看过化验结果，您可能会看到一大堆数字、隐晦的缩写和“参考范围”，这些可能适用于您的年龄、性别或身体状况，也可能不适用。 毫无疑问，它是一种诊断工具，但如果没有背景信息，它就变成了一个猜谜游戏。 即使是经验丰富的医疗保健专业人员有时也需要交叉参考指导方针、研究论文或专家意见才能理解所有内容。
这正是 FHIRInsight 的用武之地。
我们不只是为患者而构建，也为一线医护人员而构建。 为轮流值班的医生，为捕捉生命体征细微变化的护士，为每一位试图在有限的时间和巨大的责任下做出正确决定的医护人员而构建。 我们的目标是让他们的工作简单一点，将密集的临床 FHIR 数据转化为清晰、有用、以真正的医学科学为基础的东西， 讲人类语言的东西。
FHIRInsight 不仅仅是解释化验结果。 它还：
想象一下，一位年轻的医生正在查看患者的贫血检查结果。 他们不需要在 Google 上搜索每一个异常值或翻阅医学期刊，而是收到一份报告，上面不仅总结了问题，还引用了最近的研究或世界卫生组织的指导方针来支持这一推理。 这就是将 AI 与针对精选研究的矢量搜索相结合的力量。
那患者呢？
他们再也不用盯着满屏的数字，猜想“胆红素 2.3 mg/dL”是什么意思，或者他们是否应该担心了。 他们会得到简单、周全的解释。 感觉更像是一场对话，而不是一份临床报告。 一些他们能真正理解的东西 — 并与他们的医生进行讨论，让人感觉更有准备，不那么焦虑。
因为这就是 FHIRInsight 的真正意义**：将复杂的医疗数据转化为清晰的见解**，帮助医疗保健专业人员和患者共同制定更好、更自信的决策。
当然，所有这些表面上的简单，背后可能由一些默默运行的强大技术提供支持。
以下是 FHIRInsight 的构建基础：
无论您是查看 30 个患者图表的医生，还是想要理解数字含义的患者，都可以在几秒钟内将原始的化验数据转化为可解释、富有实用价值的医学见解。
在后台，FHIRInsight 的 AI 赋能报告由 LiteLLM 驱动，后者是一个出色的抽象层，可以使我们通过一个 OpenAI 风格的界面调用 100 多个 LLM（OpenAI、Claude、Gemini、Ollama 等）。
但是要想将 LiteLLM 集成到 InterSystems IRIS 中，需要比隐藏在业务操作中的 Python 脚本更持久、更能重复使用的东西。 所以，我们创建了自己的 LiteLLM 适配器。
LiteLLMAdapter此适配器类可以处理您希望从一个强大的 LLM 集成中获得的所有东西：
prompt、model 和 temperature 等参数为了将其嵌入我们的互操作性生产中，我们将其包装在一个专门的业务操作中：
LLMModel 设置处理生产配置以下是简化的核心流程：
set response = ##class(dc.LLM.LiteLLMAdapter).CallLLM("Tell me about hemoglobin.", "openai/gpt-4o", 0.7)
write response
当我们开始构建 FHIRInsight 时，我们的使命很简单**：让验血结果对每个人来说都更容易理解**。 不仅仅是患者，还有医生、护士、护理人员… 任何曾经盯着化验结果苦思冥想的人，“好吧，这到底是什么意思？”
我们都有过这样的经历。
通过融合 FHIR 的结构、InterSystems IRIS 的速度、LLM 的智能，以及通过矢量搜索实现真实医学研究的深度，我们创造了一个可以将令人困惑的数字转化成有意义的叙述的工具。 帮助人们对自己的健康做出更明智的决定，甚至可能及早发现一些被忽视的疾病。
但 FHIRInsight 不仅仅与数据相关。 它还与我们查看数据时的感受相关。 我们希望它给人一种清晰、支持和赋能的感觉。 我们希望这种体验… 有点像**“氛围编程”医疗保健** — 在智能的代码、优秀的设计和人类同理心方面达到最佳平衡点。
我们希望您能尝试它，打破它，质疑它，并帮助我们改进它。
告诉我们您接下来想看到什么。 更多条件？ 更具可解释性？ 更加个性化？
这只是一个开端 — 我们希望您能帮助塑造它的未来。
.png)
Hi 大家好
在本文中,我讲介绍我的应用 iris-AgenticAI .
代理式人工智能的兴起标志着人工智能与世界互动方式的变革性飞跃--从静态响应转变为动态、目标驱动的问题解决方式。参看 OpenAI’s Agentic SDK , OpenAI Agents SDK使您能够在一个轻量级、易用且抽象程度极低的软件包中构建代理人工智能应用程序。它是我们之前的代理实验 Swarm 的生产就绪升级版。
该应用展示了下一代自主人工智能系统，这些系统能够进行推理、协作，并以类似人类的适应能力执行复杂任务。
HI 各位开发者们，
📅2024年9月23日🕑14:00-15:30🕞，InterSystems将举办线上研讨会，点击🔔此处🔔报名参会。
此次研讨会以“面向未来的数据平台——InterSystems IRIS五大亮点提速数据潜力挖掘与AI应用”为主题，帮助您了解InterSystems IRIS数据平台的五大亮点：
InterSystems IRIS 允许从任何符合DB-API的Python应用程序对InterSystems IRIS 进行快速、无缝地访问。Python DB-API驱动是对PEP 249 v2.0（Python数据库API规范 v2.0）的完整兼容。
嗨，开发者，
我们很高兴邀请大家参加新的以 Python 为主题的 InterSystems 在线编程竞赛！
🏆 InterSystems 2024 Python 编程大赛 🏆
时间: 2024年7月15日-8月4日（美国东部时间）
奖金池: 14,000美元
.jpg)
在 OEX 最近一次编程竞赛之后，我有一些令人惊讶的发现。
几乎所有的应用程序都是基于人工智能与预制 Python 模块的结合。
但深入研究后发现，所有示例都使用了 IRIS 的相同技术组件。
从 IRIS 的角度来看，无论是搜索文本还是搜索图像或其他模式都是一样的。 其底层基本都是一样的。
这让我想起了我家里的情况。我的妻子和女儿对家里的大量裙子、衬衫和其他衣服的信息进行了整理。
但无论如何进行整理、分类、归档，我依然通过和我的妻子和女儿说话，来确定我的穿着。
无论怎样包装，其结果都是如此。
回到这次竞赛比赛：
同样的 IRIS 技术内容，却有很多花哨的包装。
每个人都在同一条高速公路上奔跑。没有人提到它有什么限制。
于是我试着深入挖掘，找出新数据类型 VECTOR 的使用限制。
所有向量都有两个基本参数
- 静态 DATATYPE："整型integer"（或 "int"）、"double"、"十进制decimal"、"字符串 "和 "时间戳"。
- 半动态 LEN(gth)： > 0 通常也称为 POSITION；纯整数。
这篇文章介绍了使用由支持 langchain 框架的IRIS来实现问答聊天机器人，其重点介绍了检索增强生成（RAG）。
文章探讨了IRIS中的向量搜索如何在langchain-iris中完成数据的存储、检索和语义搜索，从而实现对用户查询的精确、快速的响应。通过无缝集成以及索引和检索/生成等流程，由IRIS驱动的RAG应用程序使InterSystems开发者能够利用GenAI系统的能力。
为了帮助读者巩固这些概念，文章提供了Jupyter notebook和一个完整的问答聊天机器人应用程序，以供参考。
什么是RAG以及它在问答聊天机器人中的角色
RAG，即检索增强生成，是一种通过整合超出初始训练集的补充数据来丰富语言模型（LLM）知识库的技术。尽管LLM在跨不同主题进行推理方面具有能力，但它们仅限于在特定截止日期之前训练的公共数据。为了使AI应用程序能够有效处理私有或更近期的数据，RAG通过按需补充特定信息来增强模型的知识。这是一种替代微调LLM的方法，微调可能会很昂贵。
在问答聊天机器人领域，RAG在处理非结构化数据查询中发挥着关键作用，包括两个主要组成部分：索引和检索/生成。
索引从数据源摄取数据开始，然后将其分割成更小、更易于管理的块以进行高效处理。这些分割的块随后被存储和索引，通常使用嵌入模型和向量数据库，确保在运行时能够快速准确地检索。
这是在 IRIS 中完全运行向量搜索演示的尝试。
没有外部工具，您需要的只是终端/控制台和管理门户。
特别感谢Alvin Ryanputra作为他的软件包iris-vector-search的基础
灵感和测试数据的来源。
我的软件包基于 IRIS 2024.1 版本，需要注意您的处理器功能。
我尝试用纯 ObjectScript 编写演示。
仅描述向量的计算是在嵌入式Python中完成的
计算 2247 个记录的 384 维向量需要时间。
在我的 Docker 容器中，它正在运行 01:53:14 来完全生成它们。
然后被警告了！
所以我将这一步调整为可重入，以允许暂停向量计算。
每 50 条记录，您就会收到一次停止的提议。
该演示如下所示：
这是 IRIS 与 RAG（检索增强生成）示例的一个简单演示。
后端是使用 IRIS 和 IoP用 Python 编写的，LLM 模型是 orca-mini 并由 ollama 服务器提供。
前端是用 Streamlit 编写的聊天机器人。
RAG 是 Retrieval Augmented Generation（检索增强生成）的缩写，它带来了使用带有知识库的 LLM 模型（GPT-3.5/4、Mistral、Orca 等）的能力。
为什么它很重要？ 因为它允许使用知识库来回答问题，并使用 LLM 来生成答案。
例如，如果你直接向 LLM 询问**"grongier.pex 模块是什么？"**，它将无法回答，因为它不知道这个模块是什么（也许你也不知道🤪）。
但是，如果你向 RAG 提出同样的问题，它就能回答，因为它会使用知识库，知道 grongier.pex 模块是什么，从而找到答案。
既然你已经知道什么是 RAG，那就让我们来看看它是如何工作的。
首先，我们需要了解 LLMS 的工作原理。LLMS 经过训练，可以根据前一个单词预测下一个单词。因此，如果你给它一个句子，它就会尝试预测下一个词，以此类推。很简单吧？
要与 LLM 交互，通常需要给它一个提示，它就会生成句子的其余部分。例如，如果你给它一个提示 "什么是 grongier.pex 模块？
很抱歉，我对您提到的 Pex 模块并不熟悉。能否请您提供有关它的更多信息或上下文？
好的，不出所料，它不知道什么是 grongier.pex 模块。但如果我们给它一个包含答案的提示呢？例如，如果我们提示``什么是 grongier.pex 模块？它是一个可以让你做 X、Y 和 Z 的模块。`"，它就会生成剩下的句子，看起来就像这样：
grongier.pex 模块是一个可以让你执行 X、Y 和 Z 的模块。
好了，现在它知道什么是 grongier.pex 模块了。
但如果我们不知道 grongier.pex 模块是什么呢？我们怎样才能给它一个包含答案的提示呢？ 这就需要知识库了。
RAG 的整个思路是使用知识库找到上下文，然后使用 LLM 生成答案。
为了找到上下文，RAG 将使用一个**知识库。
只需克隆存储库并运行“docker-compose up”命令即可。
git clone https://github.com/grongierisc/iris-rag-demo
cd iris-rag-demo
docker-compose up
⚠️ 一切都是本地的，没有任何东西发送到云端，所以请耐心等待，可能需要几分钟才能开始。
演示开始后，您可以在 http://localhost:8051 访问前端。
![Frontend]（https://github.com/grongierisc/iris-rag-demo/blob/master/misc/iris_chat.png?raw=true）
你可以提出有关「综合注册资讯系统」的问题，例如：
![Question]（https://github.com/grongierisc/iris-rag-demo/blob/master/misc/without_rag.png?raw=true）
正如你所看到的，答案不是很好，因为 LLM 不知道什么是 grongier.pex 模块。
现在，让我们尝试使用 RAG：
上传“grongier.pex”模块文档，它位于“docs”文件夹中，文件“grongier.pex.md”。
并问同样的问题：
![Question]（https://github.com/grongierisc/iris-rag-demo/blob/master/misc/with_rag.png?raw=true）
正如你所看到的，答案要好得多，因为 LLM 现在知道什么是 grongier.pex 模块。
您可以在日志中看到详细信息：
转到管理门户， http://localhost:53795/csp/irisapp/EnsPortal.ProductionConfig.zen?$NAMESPACE=IRISAPP&$NAMESPACE=IRISAPP&，然后单击“消息”选项卡。
首先，您将看到发送到 RAG 进程的消息：
![Message]（https://github.com/grongierisc/iris-rag-demo/blob/master/misc/trace_query.png?raw=true）
然后是知识库（向量数据库）中的搜索查询：
![Message]（https://github.com/grongierisc/iris-rag-demo/blob/master/misc/trace_result_vector.png?raw=true）
最后，发送给 LLM 的新提示：
![Message]（https://github.com/grongierisc/iris-rag-demo/blob/master/misc/trace_new_query.png?raw=true）
该演示由 3 个部分组成：
前端是用 Streamlit 编写的，它是一个简单的聊天机器人，可让您提出问题。
这里没什么花哨的，只是一个简单的聊天机器人。
import os
import tempfile
import time
import streamlit as st
from streamlit_chat import message
from grongier.pex import Director
_service = Director.create_python_business_service("ChatService")
st.set_page_config(page_title="ChatIRIS")
def display_messages():
st.subheader("Chat")
for i, (msg, is_user) in enumerate(st.session_state["messages"]):
message(msg, is_user=is_user, key=str(i))
def process_input():
if st.session_state["user_input"] and len(st.session_state["user_input"].strip()) > 0:
user_text = st.session_state["user_input"].strip()
with st.spinner(f"Thinking about {user_text}"):
rag_enabled = False
if len(st.session_state["file_uploader"]) > 0:
rag_enabled = True
time.sleep(1) # help the spinner to show up
agent_text = _service.ask(user_text, rag_enabled)
st.session_state["messages"].append((user_text, True))
st.session_state["messages"].append((agent_text, False))
def read_and_save_file():
for file in st.session_state["file_uploader"]:
with tempfile.NamedTemporaryFile(delete=False,suffix=f".{file.name.split('.')[-1]}") as tf:
tf.write(file.getbuffer())
file_path = tf.name
with st.spinner(f"Ingesting {file.name}"):
_service.ingest(file_path)
os.remove(file_path)
if len(st.session_state["file_uploader"]) > 0:
st.session_state["messages"].append(
("File(s) successfully ingested", False)
)
if len(st.session_state["file_uploader"]) == 0:
_service.clear()
st.session_state["messages"].append(
("Clearing all data", False)
)
def page():
if len(st.session_state) == 0:
st.session_state["messages"] = []
_service.clear()
st.header("ChatIRIS")
st.subheader("Upload a document")
st.file_uploader(
"Upload document",
type=["pdf", "md", "txt"],
key="file_uploader",
on_change=read_and_save_file,
label_visibility="collapsed",
accept_multiple_files=True,
)
display_messages()
st.text_input("Message", key="user_input", on_change=process_input)
if __name__ == "__main__":
page()
💡 我只是在用 :
_service = Director.create_python_business_service("ChatService")
来创建一个前后端之间的绑定.
ChatService 只是互操作性生产中的简单业务服务BS。
后端是用 Python 和 IRIS 编写的。
它由3个部分组成：
业务服务是一个简单的业务服务，它允许：
from grongier.pex import BusinessService
from rag.msg import ChatRequest, ChatClearRequest, FileIngestionRequest
class ChatService(BusinessService):
def on_init(self):
if not hasattr(self, "target_chat"):
self.target_chat = "ChatProcess"
if not hasattr(self, "target_vector"):
self.target_vector = "VectorOperation"
def ingest(self, file_path: str):
# build message
msg = FileIngestionRequest(file_path=file_path)
# send message
self.send_request_sync(self.target_vector, msg)
def ask(self, query: str, rag: bool = False):
# build message
msg = ChatRequest(query=query)
# send message
response = self.send_request_sync(self.target_chat, msg)
# return response
return response.response
def clear(self):
# build message
msg = ChatClearRequest()
# send message
self.send_request_sync(self.target_vector, msg)
基本上，它只是操作和过程之间的传递。
业务流程是一个简单的过程，允许在需要时搜索知识库。
from grongier.pex import BusinessProcess
from rag.msg import ChatRequest, ChatResponse, VectorSearchRequest
class ChatProcess(BusinessProcess):
"""
the aim of this process is to generate a prompt from a query
if the vector similarity search returns a document, then we use the document's content as the prompt
if the vector similarity search returns nothing, then we use the query as the prompt
"""
def on_init(self):
if not hasattr(self, "target_vector"):
self.target_vector = "VectorOperation"
if not hasattr(self, "target_chat"):
self.target_chat = "ChatOperation"
# prompt template
self.prompt_template = "Given the context: \n {context} \n Answer the question: {question}"
def ask(self, request: ChatRequest):
query = request.query
prompt = ""
# build message
msg = VectorSearchRequest(query=query)
# send message
response = self.send_request_sync(self.target_vector, msg)
# if we have a response, then use the first document's content as the prompt
if response.docs:
# add each document's content to the context
context = "\n".join([doc['page_content'] for doc in response.docs])
# build the prompt
prompt = self.prompt_template.format(context=context, question=query)
else:
# use the query as the prompt
prompt = query
# build message
msg = ChatRequest(query=prompt)
# send message
response = self.send_request_sync(self.target_chat, msg)
# return response
return response
这真的很简单，它只是向知识库发送一条消息来搜索文档。
如果 知识库 返回文档，则会使用文档内容作为提示，否则会使用查询作为提示。
LLM 操作是一个简单的操作，可以生成答案。
class ChatOperation(BusinessOperation):
def __init__(self):
self.model = None
def on_init(self):
self.model = Ollama(base_url="http://ollama:11434",model="orca-mini")
def ask(self, request: ChatRequest):
return ChatResponse(response=self.model(request.query))
这一步也很简单，它只是向 LLM 发送一条消息来生成答案。
向量操作是一个简单的操作，允许摄取文档、搜索文档和清除向量数据库。
class VectorOperation(BusinessOperation):
def __init__(self):
self.text_splitter = None
self.vector_store = None
def on_init(self):
self.text_splitter = RecursiveCharacterTextSplitter(chunk_size=1024, chunk_overlap=100)
self.vector_store = Chroma(persist_directory="vector",embedding_function=FastEmbedEmbeddings())
def ingest(self, request: FileIngestionRequest):
file_path = request.file_path
file_type = self._get_file_type(file_path)
if file_type == "pdf":
self._ingest_pdf(file_path)
elif file_type == "markdown":
self._ingest_markdown(file_path)
elif file_type == "text":
self._ingest_text(file_path)
else:
raise Exception(f"Unknown file type: {file_type}")
def clear(self, request: ChatClearRequest):
self.on_tear_down()
def similar(self, request: VectorSearchRequest):
# do a similarity search
docs = self.vector_store.similarity_search(request.query)
# return the response
return VectorSearchResponse(docs=docs)
def on_tear_down(self):
docs = self.vector_store.get()
for id in docs['ids']:
self.vector_store.delete(id)
def _get_file_type(self, file_path: str):
if file_path.lower().endswith(".pdf"):
return "pdf"
elif file_path.lower().endswith(".md"):
return "markdown"
elif file_path.lower().endswith(".txt"):
return "text"
else:
return "unknown"
def _store_chunks(self, chunks):
ids = [str(uuid.uuid5(uuid.NAMESPACE_DNS, doc.page_content)) for doc in chunks]
unique_ids = list(set(ids))
self.vector_store.add_documents(chunks, ids = unique_ids)
def _ingest_text(self, file_path: str):
docs = TextLoader(file_path).load()
chunks = self.text_splitter.split_documents(docs)
chunks = filter_complex_metadata(chunks)
self._store_chunks(chunks)
def _ingest_pdf(self, file_path: str):
docs = PyPDFLoader(file_path=file_path).load()
chunks = self.text_splitter.split_documents(docs)
chunks = filter_complex_metadata(chunks)
self._store_chunks(chunks)
def _ingest_markdown(self, file_path: str):
# Document loader
docs = TextLoader(file_path).load()
# MD splits
headers_to_split_on = [
("#", "Header 1"),
("##", "Header 2"),
]
markdown_splitter = MarkdownHeaderTextSplitter(headers_to_split_on=headers_to_split_on)
md_header_splits = markdown_splitter.split_text(docs[0].page_content)
# Split
chunks = self.text_splitter.split_documents(md_header_splits)
chunks = filter_complex_metadata(chunks)
self._store_chunks(chunks)
如果文档太大，那么向量数据库将无法存储它们，因此我们需要将它们拆分为块。
如果文档是 PDF，那么我们将使用“PyPDFLoader”来加载 PDF，否则我们将使用“TextLoader”来加载文档。
然后，我们将使用“RecursiveCharacterTextSplitter”将文档拆分为块。
最后，我们将块存储到向量数据库中。
如果文档是 Markdown，那么我们将使用“MarkdownHeaderTextSplitter”将文档拆分为块。我们还使用标题将文档拆分为块。
所有这些都可以通过“langchains”来完成，但我想向你展示如何使用互操作性框架来做到这一点。并让每个人都更容易理解它是如何工作的。
大型语言模型（例如 OpenAI 的 GPT-4）的发明和普及掀起了一波创新解决方案浪潮，这些解决方案可以利用大量非结构化数据，在此之前，人工处理这些数据是不切实际的，甚至是不可能的。此类应用程序可能包括数据检索（请参阅 Don Woodlock 的 ML301 课程，了解检索增强生成的精彩介绍）、情感分析，甚至完全自主的 AI 代理等！
在本文中，我想演示如何使用 IRIS 的嵌入式 Python 功能直接与 Python OpenAI 库交互，方法是构建一个简单的数据标记应用程序，该应用程序将自动为我们插入IRIS 表中的记录分配关键字。然后，这些关键字可用于搜索和分类数据，以及用于数据分析目的。我将使用客户对产品的评论作为示例用例。
让我们首先创建一个 ObjectScript 类，该类将定义客户评论的数据模型。为了简单起见，我们将只定义 4 个 %String 字段：客户姓名、产品名称、评论正文以及我们将生成的关键字。该类应该扩展%Persistent，以便我们可以将其对象保存到磁盘。
如今，关于大语言模型、人工智能等的消息不绝于耳。向量数据库是其中的一部分，并且已经有非IRIS的技术实现了向量数据库。
为什么是向量？
还有许多其他原因。
因此，对于这次 pyhon 竞赛，我决定尝试实现这种支持。不幸的是我没能及时完成它，下面我将解释原因。
增强的密码管理：无缝编辑密码
在不断发展的数字安全领域，强大的密码管理工具已变得不可或缺。我们的密码管理应用程序旨在简化和保护您的在线生活，现在提供了一项增强功能 - 轻松编辑密码的能力。
为什么这个功能会改变游戏规则？
怎么运行的：
保持安全，保持井井有条：
凭借增强的编辑密码功能，我们的密码管理器为您的安全需求提供了更全面的解决方案。确保安全、井井有条并放心地管理您的密码。
下一步是什么：
对于即将到来的Python 竞赛，我想制作一个小型演示，介绍如何使用 Python 创建一个简单的 REST 应用程序，该应用程序将使用 IRIS 作为数据库。使用这个工具
假设您是一名 Python 开发人员或拥有一支训练有素的 Python 专业团队，但您分析 IRIS 中某些数据的期限很紧迫。当然，InterSystems 提供了许多用于各种分析和处理的工具。然而，在给定的场景中，最好使用旧的 Pandas 来完成工作，然后将 IRIS 留到下次使用。
对于上述情况和许多其他情况，您可能需要从 IRIS 获取表来管理 InterSystems 产品之外的数据。但是，当您有任何格式（即 CSV、TXT 或 Pickle）的外部表时，您可能还需要以相反的方式执行操作，您需要在其上导入并使用 IRIS 工具。
无论您是否必须处理上述问题，Innovatium让我明白，了解更多解决编码问题的方法总是能派上用场。好消息是，从 IRIS 引入表时，您不需要经历创建新表、传输所有行以及调整每种类型的繁琐过程。
本文将向您展示如何通过几行代码快速将 IRIS 表转换为 Pandas 数据框架并向后转换。您可以在我的GitHub上查看代码，您可以在其中找到包含本教程每个步骤的 Jupiter Notebook。
当然，您应该首先导入该项目所需的库。
import pandas as pd import sqlalchemy as db嗨，开发者，
我们很高兴邀请大家参加新的以 Python 为主题的 InterSystems 在线编程竞赛！
时间： 2023年9月4日至24日（美国东部时间）
奖金池： 14,000 美元
InterSystems IRIS 目前将类限制为 999 个属性。
但是，如果您需要为每个对象存储更多数据该怎么办？
本文将回答这个问题（附加了社区 Python 网关的客串以及如何将广泛的数据集传输到 Python 中）。
答案其实很简单 - InterSystems IRIS 目前将类限制为 999 个属性，但不限制 999 个基元(primitives)。 InterSystems IRIS 中的属性可以是具有 999 个属性的对象等等 - 该限制很容易被忽略。
FHIR 通过提供标准化数据模型来构建医疗保健应用程序并促进不同医疗保健系统之间的数据交换，彻底改变了医疗保健行业。由于 FHIR 标准基于现代 API 驱动的方法，因此移动和 Web 开发人员更容易使用它。然而，与 FHIR API 交互仍然具有挑战性，尤其是在使用自然语言查询数据时。
隆重推出FHIR - AI 和 OpenAPI 链应用程序，该解决方案允许用户使用自然语言查询与 FHIR API 进行交互。该应用程序使用OpenAI 、 LangChain和Streamlit构建，简化了查询 FHIR API 的过程并使其更加用户友好。
OpenAPI 规范（以前称为 Swagger，目前是OpenAPI Initiative的一部分）已成为软件开发领域的重要工具，使开发人员能够更有效地设计、记录 API 并与 API 交互。 OpenAPI 规范定义了一种标准的机器可读格式来描述 RESTful API，提供了一种清晰一致的方式来理解其功能并有效地使用它们。
在医疗保健领域，FHIR 成为数据交换和互操作性的领先标准。为了增强FHIR的互操作能力， HL7正式记录了FHIR OpenAPI规范，使开发人员能够将FHIR资源和操作无缝集成到他们的软件解决方案中。
本文是 SqlDatabaseChain 的简单快速入门（我所做的）。
希望大家会感兴趣。
非常感谢：
sqlalchemy-iris 作者@Dmitry Maslennikov
您的项目使我的试验变得可能。
文章脚本使用 openai API，因此请注意不要在外部共享您不打算共享的表信息和记录。
如果需要，可以插入本地模型。
在最近几篇文章中的一些文章中，我谈到了 IRIS 和 Python 之间的类型，很明显，从一侧到另一侧访问对象并不是那么容易。
幸运的是，已经完成了创建SQLAlchemy-iris 的工作（点击链接在 Open Exchange 上查看它），这使得 Python 访问 IRIS 对象的一切变得更加容易，我将展示它的启动器。
要安装，只需打开具有管理员权限的终端并输入
pip install sqlalchemy-iris如果需要，这还将为您安装先决条件。
现在，在 python 文件上，您可以导入模块、连接到数据库并以任何您想要的方式使用 sqlalchemy。如果你觉得舒服，你可以按照以下步骤操作：
InterSystems IRIS 2022.2 具有适用于 Python 的原生 SDK (https://docs.intersystems.com/iris20222/csp/docbook/Doc.View.cls?KEY=PA…)。
我们知道如何使用 IRIS Object Script $Order 函数遍历Global数据结构。
SET key= ""FOR { SET key= $ORDER ( ^myglobal (key)) QUIT :key= ""WRITE !, ^myglobal (key) }如何使用 IRIS Native SDK 从 Python 执行相同的操作？这里有一个代码示例：
在这里，您将找到一个在 IRIS 环境中使用 Python 的简单程序，以及另一个在 Python 环境中使用 ObjectScript 的简单程序。另外，我想分享一些我在学习实践时遇到的麻烦。
比方说，您在 IRIS 环境中想要解决一个您认为使用 Python 更容易或更有效的问题。
您可以简单地更改环境：像创建任何其他方法一样创建您的方法，并在其名称和规范的末尾添加 [Language = python]：
您可以在该方法中使用任何类型的参数，并且要访问它们，您可以执行与在 COS 中完全相同的操作：
假设您有这个 %String 参数 Arg 和一个来自自定义类的参数 OtherArg。这个其他类可能具有标题和作者等属性。您希望像这样访问：
此方法提供如下输出：
而且，对于访问类方法，它几乎是一样的。假设我们在 Demo.Books.PD.Books 中有一个名为“CreateString”的方法，它将标题和作者连接成类似于“Title: <Title>; Author: <Author>”的内容。
将其添加到我们的 python 方法的末尾：
将提供以下输出：
（要访问该方法，您可以使用 OtherArg.CreateString()，但我选择将 OtherArg 中的相同值传递给 CreateString 方法，以便输出看起来相似并且代码看起来更简单）
您好，我们的客户仍在使用较旧的 cache 2016.1 版本，我们这边需要适配 python 作为 client 连接 cache 进行一些操作。 但是查阅相关文档后发现，需要自行编译安装 python 驱动。
我们手头上只有 windows 版本的 cache 安装包，但是我们python适配的环境是 linux。 所以我想找一下是否有 cache 现有的 python 安装包或者 cache linux 安装版本，我自行安装。
谢谢。
Python 已成为世界上使用最广泛的编程语言（来源：https://www.tiobe.com/tiobe-index/），SQL 作为数据库语言继续引领潮流。 Python 和 SQL 一起工作以提供 SQL 单独无法提供的新功能不是很好吗？毕竟，Python 拥有超过 380,000 个已发布的库（来源：https://pypi.org/），它们具有非常有趣的功能，可以在 Python 中扩展您的 SQL 查询。本文详细介绍了如何使用嵌入式 Python 在 InterSystems IRIS 数据库中创建新的 SQL 存储过程。
本文将使用两个非常有用的库：Geopy 和 Chronyk。
Geopy 是一个用于将地理编码（地址和地理坐标的限定）应用于地址数据的库。有了它，就可以从街道名称中获取邮局格式的邮政编码和完整地址。非常有用，因为许多记录都有地址。
Chronyk 用于使用人类语言处理日期和时间。这非常有用，因为在内部，对于 IRIS 和 Python，日期是一个数字，表示自初始日期以来经过的时间量。对于人类来说，日期是 7 月 20 日，或者昨天，或者明天，或者两个小时前。 Chronyk 接受接收这样的日期，然后将其转换为通用日期格式。
这个项目是在我考虑如何通过Embedded Python让Python代码自然地处理IRIS globals所提供的可扩展的存储和高效的检索机制时想到的。
我最初的想法是使用globals创建一种Python字典的实现，但很快我就意识到，我应该首先处理对象的抽象问题。
所以，我开始创建一些可以包装Python对象的Python类，在globals中存储和检索它们的数据，也就是说，在IRIS globals中序列化和反序列化Python对象。
像 ObjectScript 的%DispatchGetProperty(), %DispatchSetProperty() 和%DispatchMethod()一样, Python 有委托对象的属性和方法调用的方式。
当你设置或获取一个对象属性时，Python 解释器让你通过方式 __setattr__(self, name, value) 和 __getattr(self, name)__来截获这个操作。
请看这个相当基本的例子。
公司需要统计数据，需要使用python连接数据库查询，请问一下如何使用python连接cache2016数据库
此篇文章给大家介绍一个使用pyodbc连接到 InterSystems IRIS数据库的示例，详情如下：
InterSystems IRIS 安装在Redhat 操作系统中，使用pyodbc在Mac操作系统中连接到Redhat 操作系统中InterSystems IRIS数据库。