LangGraph/LangChain에서 Haystack로 마이그레이션하기

LangGraph/LangChain에서 Haystack로 마이그레이션하기 (Migrating from LangGraph/LangChain to Haystack)

Haystack로 마이그레이션할 계획이거나, 아니면 그냥 AI 애플리케이션에 맞는 프레임워크를 고르려고 LangChain/LangGraph와 Haystack을 비교하고 있다면, 이 가이드가 프레임워크 간의 공통 패턴을 대응(맵핑)해 주는 데 도움이 돼요.

출처: 공식문서

이 가이드에서는 LangGraph의 핵심 개념인 node, edge, state를 Haystack의 component, pipeline, agent로 어떻게 옮기는지 배워요. 목표는 기존 로직을 보존하면서 Haystack의 유연하고 모듈식 생태계를 활용하는 것이에요.

사실 Haystack은 LangChain과 LangGraph의 영역을 모두 아우른다고 보는 게 정확해요. Haystack은 단순 순차 흐름에서 커스텀 로직을 가진 완전한 에이전틱 워크플로까지, 모든 것을 위한 빌딩 블록을 제공하니까요.

왜 Haystack으로 옮겨오나요

AI 애플리케이션을 안정적이고 활발히 유지 관리되는 기반과 직관적인 개발자 경험 위에 짓고 싶다면 Haystack을 고려해 볼 만해요.

• 통합 오케스트레이션 프레임워크. Haystack은 결정적인 파이프라인과 적응형 에이전틱 흐름을 모두 지원해서, 한 시스템 안에서 원하는 수준의 자율성으로 둘을 결합할 수 있어요.
• 고품질 코드베이스와 설계. Haystack은 명확성과 신뢰성을 위해 설계됐어요. 잘 테스트된 컴포넌트, 예측 가능한 API, 그리고 그냥 잘 동작하는 모듈식 아키텍처를 갖추고 있죠.
• 커스터마이징이 쉽다. 핵심 컴포넌트를 확장하거나, 나만의 로직을 추가하거나, 커스텀 도구를 통합하는 데 마찰이 거의 없어요.
• 인지 부하 감소. Haystack은 새로운 추상화를 도입하기보다 익숙한 개념을 확장해서, 개념을 배우는 데 집중하기보다 적용하는 데 집중할 수 있게 해 줘요.
• 포괄적인 문서와 학습 자료. 컴포넌트와 파이프라인부터 에이전트와 도구까지 모든 개념이 상세하고 잘 관리되는 문서, 튜토리얼, 교육 자료로 뒷받침돼요.
• 빈번한 릴리스 주기. 새 기능과 개선, 버그 수정이 정기적으로 배포되어, 프레임워크가 역호환성을 유지하면서 빠르게 진화해요.
• 프로토타입에서 프로덕션까지 확장. 작게 시작해서 쉽게 확장할 수 있어요. 개념 증명에서 쓰던 코드가 Haystack 전체 생태계를 통해 엔터프라이즈급 배포로 이어질 수 있죠.

개념 매핑: LangGraph/LangChain → Haystack

두 프레임워크의 주요 개념과 대략적인 등가물을 표로 정리했어요. LangGraph/LangChain 아키텍처를 감사하고 마이그레이션을 계획할 때 이 표를 활용해 보세요.

LangGraph/LangChain 개념	Haystack 등가물	참고
Node	Component	두 프레임워크 모두에서 로직의 단위예요. Haystack에서 Component는 단독, 파이프라인 안, 또는 에이전트의 도구로 실행될 수 있어요. 커스텀 컴포넌트를 만들거나 Generator·Retriever 같은 내장 컴포넌트를 쓸 수 있죠.
Edge / 라우팅 로직	Connection / Branching / Looping	Pipelines은 타입이 검사된 링크로 컴포넌트 입력·출력을 연결해요. 유연한 흐름 제어를 위한 분기, 라우팅, 루프를 지원하죠.
Graph / Workflow (nodes + edges)	Pipeline 또는 Agent	LangGraph는 그래프를 명시적으로 정의해요. Haystack은 파이프라인이나, 적응형 로직이 필요할 때 Agent를 통해 비슷한 오케스트레이션을 이뤄요.
Subgraphs	SuperComponent	SuperComponent은 전체 파이프라인을 감싸서 재사용 가능한 단일 컴포넌트로 노출해요.
Models / LLMs	ChatGenerator Components	Haystack의 ChatGenerators는 오픈·프로프라이어터리 모델에 대한 액세스를 통합하고, 스트리밍·구조화 출력·멀티모달 데이터를 지원해요.
Agent 생성 (create_agent, LangChain의 멀티 에이전트)	Agent Component	Haystack은 파이프라인 기반의 단순한 Agent 추상화를 제공해서 추론, 도구 사용, 다단계 실행을 처리해요.
Tool (Langchain)	Tool / PipelineTool / ComponentTool / AgentTool / MCPTool	Haystack은 파이썬 함수, 파이프라인, 컴포넌트, 외부 API, MCP 서버를 에이전트 도구로 노출해요.
Multi-Agent 협업 (LangChain)	Multi-Agent System	AgentTool을 사용하면 에이전트가 다른 에이전트를 도구로 사용할 수 있어서, 한 프레임워크 안에서 멀티 에이전트 아키텍처를 구성할 수 있어요.
Model Context Protocol load_mcp_tools / MultiServerMCPClient	Model Context Protocol - MCPTool, MCPToolset, StdioServerInfo, StreamableHttpServerInfo	Haystack은 여러 MCP 서버 연결과 MCP 툴셋 구성을 위한 다양한 MCP 프리미티브를 제공해요.
Memory (State, 단기·장기)	Memory (Agent State, 단기·장기)	Agent State는 에이전트 실행 중 도구 간 데이터 공유와 중간 결과 저장을 위한 구조화된 방법을 제공해요. 장기 메모리는 Mem0MemoryStore나 CogneeeMemoryStore 같은 메모리 스토어로 세션 간 대화 기록을 유지할 수 있어요.
Time travel (Checkpoints)	Breakpoints (Breakpoint, PipelineSnapshot)	Breakpoints로 파이프라인을 일시 중지·검사·수정·재개해서 디버깅하거나 반복 개발할 수 있어요.
Human-in-the-Loop (Interrupts / Commands)	Human-in-the-loop (ConfirmationHook + 인증 전략)	Haystack은 Agent의 before_tool 훅 포인트에 등록된 ConfirmationHook을 통해 인증 전략을 적용해, 사용자 피드백을 받기 위해 실행을 일시 중지하거나 차단해요.

생태계·도구 매핑: LangChain → Haystack

deepset에서는 LLM을 프로덕션에서 진짜 쓸 수 있게 만드는 도구들을, 오픈 소스와 그 너머까지 만들어 가고 있어요.

• Haystack, AI Orchestration Framework → 프로덕션에 바로 쓸 수 있는 AI 에이전트·애플리케이션 구축용 오픈소스 AI 프레임워크. 혼자서 또는 커뮤니티 지원으로 쓸 수 있어요.
• Haystack Enterprise Starter → 더 많은 지원과 가이드가 필요한 팀을 위한 프라이빗·시큐어 엔지니어링 지원, 고급 파이프라인 템플릿, 배포 가이드, 조기 액세스 기능.
• Haystack Enterprise Platform → 프로덕션에서 Gen AI 앱을 운영하는 팀을 위한 엔터프라이즈 플랫폼. 보안·거버넌스·확장성이 내장돼 있고 무료 버전도 있어요.

두 생태계의 제품 등가물은 이렇습니다.

LangChain 생태계	Haystack 생태계	참고
LangChain, LangGraph, Deep Agents	Haystack	컴포넌트·파이프라인·에이전트를 위한 핵심 AI 오케스트레이션 프레임워크. 명시적이고 모듈식인 빌딩 블록으로 결정적 워크플로와 에이전틱 실행을 지원해요.
LangSmith (Observability)	Haystack Enterprise Platform	빌드·디버그·반복을 위한 통합 도구. Builder로 에이전트와 파이프라인을 시각적으로 조립할 수 있고(컴포넌트 검증·테스트·디버깅 포함), Prompt Explorer로 모델과 프롬프트를 반복·평가해요. 내장 채팅 인터페이스로 SME·이해관계자의 빠른 피드백을 받고, 엔지니어와 비즈니스가 함께 협업하는 빌드 환경을 제공하죠.
LangSmith (Deployment)	Hayhooks / Haystack Enterprise Starter (배포 가이드 + 고급 모범 사례 템플릿) / Haystack Enterprise Platform (1-클릭 배포, 온프렘/VPC 옵션)	여러 배포 경로가 있어요: Hayhooks로 가벼운 API 노출, Haystack Enterprise Starter로 구조화된 엔터프라이즈 배포 패턴, Haystack Enterprise Platform으로 완전 관리형 또는 자체 호스팅 배포가 가능하죠.

코드 비교

Haystack vs LangGraph 에이전틱 흐름

도구 리스트에 접근할 수 있는 그래프 기반 에이전트 예제로 LangGraph와 Haystack API를 비교해 볼게요.

Step 1: 도구 정의

두 프레임워크 모두 @tool 데코레이터를 사용해 파이썬 함수를 LLM이 호출할 수 있는 도구로 노출해요. 함수 시그니처와 독스트링이 도구의 인터페이스를 정의하고, LLM은 이를 보고 언제·어떻게 각 도구를 호출할지 파악해요.

Haystack:

# pip install haystack-ai anthropic-haystack

from haystack.tools import tool

# Define tools

@tool
def multiply(a: int, b: int) -> int:
  """Multiply `a` and `b`.

  Args:
      a: First int
      b: Second int
  """
  return a * b

@tool
def add(a: int, b: int) -> int:
  """Adds `a` and `b`.

  Args:
      a: First int
      b: Second int
  """
  return a + b

@tool
def divide(a: int, b: int) -> float:
  """Divide `a` and `b`.

  Args:
      a: First int
      b: Second int
  """
  return a / b

LangGraph + LangChain:

# pip install langchain-anthropic langgraph langchain

from langchain.tools import tool

# Define tools

@tool
def multiply(a: int, b: int) -> int:
  """Multiply `a` and `b`.

  Args:
      a: First int
      b: Second int
  """
  return a * b

@tool
def add(a: int, b: int) -> int:
  """Adds `a` and `b`.

  Args:
      a: First int
      b: Second int
  """
  return a + b

@tool
def divide(a: int, b: int) -> float:
  """Divide `a` and `b`.

  Args:
      a: First int
      b: Second int
  """
  return a / b

Step 2: LLM 초기화

이제 프레임워크가 도구를 LLM에 연결하는 방식이 달라져요. Haystack에서는 여기서 ChatGenerator 컴포넌트만 초기화해요. 도구는 Step 3에서 Agent에 전달되고, 에이전트가 LLM으로 넘겨주죠. LangGraph에서는 먼저 모델을 초기화한 뒤 .bind_tools()로 도구를 바인딩해서 도구가 활성화된 LLM 인스턴스를 만들어요.

Haystack:

from haystack_integrations.components.generators.anthropic import AnthropicChatGenerator

# Initialize the LLM; the tools are passed to the Agent in Step 3

tools = [add, multiply, divide]

model = AnthropicChatGenerator(
  model="claude-sonnet-4-5-20250929",
  generation_kwargs={"temperature": 0},
)

LangGraph + LangChain:

from langchain.chat_models import init_chat_model

# Augment the LLM with tools

model = init_chat_model(
  "claude-sonnet-4-5-20250929",
  temperature=0,
)

tools = [add, multiply, divide]

tools_by_name = {tool.name: tool for tool in tools}

llm_with_tools = model.bind_tools(tools)

Step 3: 에이전트 조립

여기가 프레임워크 간 차이가 가장 큰 부분이에요. Haystack에서는 chat generator와 도구로 Agent 컴포넌트를 만드는데, 에이전틱 루프는 이미 내장되어 있어요. 에이전트가 대화(LLM 답변과 도구 결과)를 내부적으로 누적하고, LLM이 준비한 도구 호출을 실행하며, 종료 조건을 만날 때까지 반복해요. 기본 exit_conditions=["text"]는 LLM이 도구 호출 없이 답변하면 루프를 멈춰요. 도구 이름을 사용해 특정 도구가 실행된 뒤 종료하게 할 수도 있어요.

LangGraph에서는 루프를 명시적으로 만들어요. 누적된 MessagesState에서 LLM을 호출하는 노드 함수(llm_call), 도구 호출을 실행하고 결과를 ToolMessage 객체로 감싸는 노드 함수(tool_node), 루프를 계속할지 끝낼지를 결정하는 조건부 엣지 함수(should_continue)를 만들고, 노드와 엣지를 StateGraph에서 연결한 뒤 그래프를 컴파일해서 실행 가능한 에이전트로 만드는 식이죠.

Haystack:

from haystack.components.agents import Agent

# Create the agent - the agentic loop (LLM calls,
# tool execution, iteration) is built in

agent = Agent(
  chat_generator=model,
  tools=tools,
  system_prompt="You are a helpful assistant tasked with performing arithmetic on a set of inputs.",
  exit_conditions=["text"],  # default
)

LangGraph + LangChain:

from typing import Literal

from langgraph.graph import MessagesState, StateGraph, START, END
from langchain.messages import SystemMessage, ToolMessage

# Node: the LLM decides whether to call a tool or not

def llm_call(state: MessagesState):
  return {
      "messages": [
          llm_with_tools.invoke(
              [
                  SystemMessage(
                      content="You are a helpful assistant tasked with performing arithmetic on a set of inputs."
                  )
              ]
              + state["messages"]
          )
      ]
  }

# Node: performs the tool calls

def tool_node(state: dict):
  result = []
  for tool_call in state["messages"][-1].tool_calls:
      tool = tools_by_name[tool_call["name"]]
      observation = tool.invoke(tool_call["args"])
      result.append(ToolMessage(content=observation, tool_call_id=tool_call["id"]))
  return {"messages": result}

# Conditional edge: route to the tool node or end
# based upon whether the LLM made a tool call

def should_continue(state: MessagesState) -> Literal["tool_node", END]:
  last_message = state["messages"][-1]
  if last_message.tool_calls:
      return "tool_node"
  return END

# Build workflow

agent_builder = StateGraph(MessagesState)

# Add nodes

agent_builder.add_node("llm_call", llm_call)
agent_builder.add_node("tool_node", tool_node)

# Add edges to connect nodes

agent_builder.add_edge(START, "llm_call")
agent_builder.add_conditional_edges(
  "llm_call",
  should_continue,
  ["tool_node", END]
)
agent_builder.add_edge("tool_node", "llm_call")

# Compile the agent

agent = agent_builder.compile()

Step 4: 에이전트 실행

마지막으로 사용자 메시지로 에이전트를 실행해요. Haystack은 초기 메시지로 Agent에 .run()을 호출하고, LangGraph는 컴파일된 에이전트에 .invoke()를 호출해요. 둘 다 대화 기록을 반환해요.

Haystack:

from haystack.dataclasses import ChatMessage

# Run the agent

result = agent.run(messages=[
  ChatMessage.from_user(text="Add 3 and 4.")
])
print(result["last_message"].text)

LangGraph + LangChain:

from langchain.messages import HumanMessage

# Invoke

messages = [
  HumanMessage(content="Add 3 and 4.")
]

messages = agent.invoke({"messages": messages})

for m in messages["messages"]:
  m.pretty_print()

에이전트 만들기 (Creating Agents)

위의 Agentic Flows 워크스루는 에이전트 루프를 한 조각씩 짚어 봤어요. Haystack에서 고수준 Agent 클래스는 전체 루프 — LLM 호출, 도구 실행, 반복 — 를 단일 컴포넌트로 감싸요. LangGraph는 langgraph.prebuilt의 create_react_agent로 이에 상응하는 지름길을 제공해요. 둘 다 ReAct 스타일 에이전트를 만들어서 도구 호출과 다단계 추론을 자동으로 처리해요. 완전한 예제를 나란히 보여 드릴게요.

Haystack:

# pip install haystack-ai anthropic-haystack

from haystack.components.agents import Agent
from haystack_integrations.components.generators.anthropic import AnthropicChatGenerator
from haystack.dataclasses import ChatMessage
from haystack.tools import tool

@tool
def multiply(a: int, b: int) -> int:
  """Multiply `a` and `b`."""
  return a * b

@tool
def add(a: int, b: int) -> int:
  """Add `a` and `b`."""
  return a + b

# Create an agent  -  the agentic loop is handled automatically

agent = Agent(
  chat_generator=AnthropicChatGenerator(
      model="claude-sonnet-4-5-20250929",
      generation_kwargs={"temperature": 0},
  ),
  tools=[multiply, add],
  system_prompt="You are a helpful assistant that performs arithmetic.",
)

result = agent.run(messages=[
  ChatMessage.from_user("What is 3 multiplied by 7, then add 5?")
])
print(result["messages"][-1].text) # or print(result["last_message"].text)

LangGraph + LangChain:

# pip install langchain-anthropic langgraph

from langchain_anthropic import ChatAnthropic
from langchain_core.tools import tool
from langchain.agents import create_agent
from langchain_core.messages import HumanMessage, SystemMessage

@tool
def multiply(a: int, b: int) -> int:
  """Multiply `a` and `b`."""
  return a * b

@tool
def add(a: int, b: int) -> int:
  """Add `a` and `b`."""
  return a + b

# Create an agent - the agentic loop is handled automatically

model = ChatAnthropic(
  model="claude-sonnet-4-5-20250929",
  temperature=0,
)

agent = create_agent(
  model,
  tools=[multiply, add],
  system_prompt=SystemMessage(
      content="You are a helpful assistant that performs arithmetic."
  ),
)

result = agent.invoke({
  "messages": [HumanMessage(content="What is 3 multiplied by 7, then add 5?")]
})
print(result["messages"][-1].content)

Document Store 연결하기 (Connecting to Document Stores)

Document Store는 검색 증강 생성(RAG)의 기반이에요. Haystack에서 Document Store는 명시적이고 타입이 지정된 연결을 통해 Retriever, Prompt Builder 같은 파이프라인 컴포넌트와 네이티브로 통합돼요. LangChain은 벡터 스토어 추상화를 중심으로 검색을 구성하고, 이를 LCEL(LangChain Expression Language)로 조합하죠.

두 프레임워크 모두 프로토타이핑용 인메모리 스토어와, 통합을 통한 광범위한 프로덕션 백엔드(Elasticsearch, Qdrant, Weaviate, Pinecone 등)를 제공해요.

Step 1: Document Store를 만들고 문서 추가

Haystack:

# pip install haystack-ai sentence-transformers-haystack

from haystack import Document
from haystack.document_stores.in_memory import InMemoryDocumentStore
from haystack_integrations.components.embedders.sentence_transformers import SentenceTransformersDocumentEmbedder

# Embed and write documents to the document store

document_store = InMemoryDocumentStore()

doc_embedder = SentenceTransformersDocumentEmbedder(
  model="sentence-transformers/all-MiniLM-L6-v2"
)

docs = [
  Document(content="Paris is the capital of France."),
  Document(content="Berlin is the capital of Germany."),
  Document(content="Tokyo is the capital of Japan."),
]

docs_with_embeddings = doc_embedder.run(docs)["documents"]
document_store.write_documents(docs_with_embeddings)

LangChain:

# pip install langchain-community langchain-huggingface sentence-transformers

from langchain_huggingface import HuggingFaceEmbeddings
from langchain_community.vectorstores import InMemoryVectorStore
from langchain_core.documents import Document

# Embed and add documents to the vector store

embeddings = HuggingFaceEmbeddings(
  model_name="sentence-transformers/all-MiniLM-L6-v2"
)

vectorstore = InMemoryVectorStore(embedding=embeddings)
vectorstore.add_documents([
  Document(page_content="Paris is the capital of France."),
  Document(page_content="Berlin is the capital of Germany."),
  Document(page_content="Tokyo is the capital of Japan."),
])

Step 2: RAG 파이프라인 구축

Haystack:

from haystack import Pipeline
from haystack_integrations.components.embedders.sentence_transformers import SentenceTransformersTextEmbedder
from haystack.components.retrievers.in_memory import InMemoryEmbeddingRetriever
from haystack.components.builders import ChatPromptBuilder
from haystack.dataclasses import ChatMessage
from haystack_integrations.components.generators.anthropic import AnthropicChatGenerator

# ChatPromptBuilder expects a list[ChatMessage] as template

template = [ChatMessage.from_user("""\
Given the following documents, answer the question.
{% for doc in documents %}{{ doc.content }}{% endfor %}

Question: {{ question }}
""")]

rag_pipeline = Pipeline()
rag_pipeline.add_component(
  "text_embedder",
  SentenceTransformersTextEmbedder(model="sentence-transformers/all-MiniLM-L6-v2")
)
rag_pipeline.add_component(
  "retriever", InMemoryEmbeddingRetriever(document_store=document_store)
)
rag_pipeline.add_component(
  "prompt_builder", ChatPromptBuilder(template=template)
)
rag_pipeline.add_component(
  "llm", AnthropicChatGenerator(model="claude-sonnet-4-5-20250929")
)

rag_pipeline.connect("text_embedder.embedding", "retriever.query_embedding")
rag_pipeline.connect("retriever.documents", "prompt_builder.documents")
rag_pipeline.connect("prompt_builder.prompt", "llm.messages")

result = rag_pipeline.run({
  "text_embedder": {"text": "What is the capital of France?"},
  "prompt_builder": {"question": "What is the capital of France?"},
})
print(result["llm"]["replies"][0].text)

LangChain:

from langchain_anthropic import ChatAnthropic
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough

def format_docs(docs):
  return "\n".join(doc.page_content for doc in docs)

retriever = vectorstore.as_retriever()
model = ChatAnthropic(model="claude-sonnet-4-5-20250929")

template = """
Given the following documents, answer the question.
{context}

Question: {question}

"""

prompt = ChatPromptTemplate.from_template(template)

rag_chain = (
  {"context": retriever | format_docs, "question": RunnablePassthrough()}
  | prompt
  | model
  | StrOutputParser()
)

result = rag_chain.invoke("What is the capital of France?")
print(result)

MCP 도구 사용하기 (Using MCP Tools)

두 프레임워크 모두 Model Context Protocol(MCP)을 지원해서, 에이전트가 MCP 서버가 노출하는 외부 도구와 서비스에 연결할 수 있어요. Haystack은 mcp-haystack 통합 패키지를 통해 MCPTool과 MCPToolset을 제공하며, 이들은 Agent 컴포넌트에 바로 연결돼요. LangChain의 MCP 지원은 별도의 langchain-mcp-adapters 패키지에 의존하고, 전체 워크플로에서 비동기를 요구해요.

Haystack:

# pip install haystack-ai mcp-haystack anthropic-haystack

from haystack_integrations.tools.mcp import MCPToolset, StdioServerInfo
from haystack.components.agents import Agent
from haystack_integrations.components.generators.anthropic import AnthropicChatGenerator
from haystack.dataclasses import ChatMessage

# Connect to an MCP server - tools are auto-discovered

toolset = MCPToolset(
  server_info=StdioServerInfo(
      command="uvx",
      args=["mcp-server-fetch"],
  )
)

agent = Agent(
  chat_generator=AnthropicChatGenerator(model="claude-sonnet-4-5-20250929"),
  tools=toolset,
  system_prompt="You are a helpful assistant that can fetch web content.",
)

result = agent.run(messages=[
  ChatMessage.from_user("Fetch the content from https://haystack.deepset.ai")
])
print(result["messages"][-1].text) # or print(result["last_message"].text)

LangGraph + LangChain:

# pip install langchain-mcp-adapters langgraph langchain-anthropic

import asyncio

from langchain_mcp_adapters.client import MultiServerMCPClient
from langchain.agents import create_agent
from langchain_anthropic import ChatAnthropic
from langchain_core.messages import HumanMessage, SystemMessage

model = ChatAnthropic(model="claude-sonnet-4-5-20250929")

async def run():
  client = MultiServerMCPClient(
      {
          "fetch": {
              "command": "uvx",
              "args": ["mcp-server-fetch"],
              "transport": "stdio",
          }
      }
  )
  tools = await client.get_tools()

  agent = create_agent(
      model,
      tools,
      system_prompt=SystemMessage(
          content="You are a helpful assistant that can fetch web content."
      ),
  )

  result = await agent.ainvoke(
      {
          "messages": [
              HumanMessage(content="Fetch the content from https://haystack.deepset.ai")
          ]
      }
  )
  print(result["messages"][-1].content)

asyncio.run(run())

Haystack 사용자들의 이야기

업계 전반의 팀들이 어떻게 Haystack으로 RAG 애플리케이션부터 에이전틱 워크플로까지 프로덕션 AI 시스템을 운영하는지 살펴보세요.

" Haystack allows its users a production ready, easy to use framework that covers just about all of your needs, and allows you to write integrations easily for those it doesn't." - Josh Longenecker, GenAI Specialist at AWS

"Haystack's design philosophy significantly accelerates development and improves the robustness of AI applications, especially when heading towards production. The emphasis on explicit, modular components truly pays off in the long run." - Rima Hajou, Data & AI Technical Lead at Accenture

추천 사례 (Featured Stories)

• TELUS Agriculture & Consumer Goods Built an Agentic Chatbot with Haystack to Transform Trade Promotions Workflows
• Lufthansa Industry Solutions Uses Haystack to Power Enterprise RAG

Haystack로 작업 시작하기

👉 마이그레이션이나 평가를 고려하고 있나요? Haystack Get Started 가이드로 바로 시작하거나 팀에 문의해 보세요. 기꺼이 지원해 드릴게요.

더 알아보기 (Learn more)

• LangGraph/LangChain에서 Haystack로 마이그레이션하기 - 공식문서