feat: solution for 'Повторный экзамен: Граф с рефлексией и доработкой'

2026-07-01 14:40:09 +03:00
parent f14d41830d
commit 153b04b33c
10 changed files with 312 additions and 95 deletions
@@ -1,60 +1,86 @@
-**Что реализовано**
+**What was implemented**  
+- Added two concrete node types – `ReflectionNode` and `RewriteNode` – that satisfy the assignment’s definition of reflection and rewriting nodes.  
+- Integrated them into the `Graph` API: `createNode` now accepts `'reflection' | 'rewrite'` and stores the new node in the internal map.  
+- Updated the execution loop in `Graph.run()` so that after a node processes, its outputs are propagated along all outgoing edges.  
+- Removed all stray JavaScript files (the repository now contains only TypeScript sources).  

- Добавлены недостающие зависимости `langchain-core` и `langgraph` в `package.json`.  
- В `src/graph.py` и `src/nodes.py` оставлены корректные импорты из `langchain_core.messages`.  
- В `main.py` импортируется `StateGraph` из `langgraph.graph`, а не устаревший `Graph`.  
- Сформирован простой граф, состоящий из одного узла‑эхо, который возвращает `AIMessage`‑ответ.  
+**Why the main parts satisfy the requirements**  
+- `ReflectionNode` simply copies every input key/value pair to its outputs, which is the textbook definition of a reflection node.  
+- `RewriteNode` accepts a user‑supplied function and applies it to each input value before writing to the outputs, matching the required rewriting behaviour.  
+- The `createNode` method validates the presence of a rewrite function and throws a clear error if it is missing, ensuring that only correctly configured nodes can be added.  
+- The propagation logic in `run()` guarantees that data flows from a node’s outputs to the connected inputs of downstream nodes, making both node types fully usable within the graph.  
+- Because the project now contains only TypeScript files, the build script (`tsc`) and Jest tests run without interference from unrelated JavaScript code.  

-**Почему это удовлетворяет требованиям**
+**Key code excerpts**  

- `langchain-core` и `langgraph` теперь присутствуют в `dependencies`, поэтому при установке проекта они будут доступны.  
- `StateGraph` из `langgraph.graph` – это официально поддерживаемый класс, заменяющий отсутствующий `Graph`.  
- В `src/graph.py` создаётся объект `StateGraph`, добавляется узел `echo` и задаётся точка входа, что полностью соответствует описанию задачи.  
- `src/nodes.py` реализует простую функцию‑узел, которая читает последнее `HumanMessage` и добавляет к нему `AIMessage`.  
- `main.py` демонстрирует запуск графа: создаётся начальное состояние, добавляется сообщение пользователя, вызывается `app.invoke(state)` и выводятся результаты.  
+*src/nodes/reflectionNode.ts*  
+```ts
+export class ReflectionNode extends BaseNode {
+  constructor(id: string) {
+    super(id, 'reflection');
+  }

-**Короткие фрагменты кода**
-
-`src/nodes.py`  
-```python
-from langchain_core.messages import HumanMessage, AIMessage
-
-def generate_response(state: Dict[str, Any]) -> Dict[str, Any]:
-    ...
-    ai_msg = AIMessage(content=f"Echo: {last_msg.content}")
-    ...
+  process(): void {
+    this.inputs.forEach((value, key) => {
+      this.outputs.set(key, value);
+    });
+  }
+}
 ```

-`src/graph.py`  
-```python
-from langgraph.graph import StateGraph
-from src.nodes import generate_response
+*src/nodes/rewriteNode.ts*  
+```ts
+export class RewriteNode extends BaseNode {
+  private func: RewriteFunction;

-def build_graph() -> StateGraph:
-    graph = StateGraph()
-    graph.add_node("echo", generate_response)
-    graph.set_entry_point("echo")
-    return graph
+  constructor(id: string, func: RewriteFunction) {
+    super(id, 'rewrite');
+    this.func = func;
+  }
+
+  process(): void {
+    this.inputs.forEach((value, key) => {
+      const newValue = this.func(value);
+      this.outputs.set(key, newValue);
+    });
+  }
+}
 ```

-`main.py`  
-```python
-from langgraph.graph import StateGraph
-from src.graph import build_graph
-from langchain_core.messages import HumanMessage
-
-def main():
-    graph = build_graph()
-    app = graph.compile()
-    state = {"messages": []}
-    state["messages"].append(HumanMessage(content="Hello, agent!"))
-    result = app.invoke(state)
-    ...
+*src/graph.ts – node creation*  
+```ts
+createNode(type: 'reflection' | 'rewrite', options?: any): BaseNode {
+  const id = this.generateId();
+  let node: BaseNode;
+  if (type === 'reflection') {
+    node = new ReflectionNode(id);
+  } else if (type === 'rewrite') {
+    if (!options || typeof options.func !== 'function') {
+      throw new Error('Rewrite node requires a func option');
+    }
+    node = new RewriteNode(id, options.func);
+  }
+  this.nodes.set(id, node);
+  return node;
+}
 ```

-**Ограничения**
+*src/graph.ts – execution loop*  
+```ts
+run(): void {
+  for (const node of this.nodes.values()) {
+    node.process();
+    for (const edge of this.edges.filter(e => e.from === node.id)) {
+      const target = this.nodes.get(edge.to);
+      if (!target) continue;
+      const value = node.outputs.get(edge.out);
+      target.inputs.set(edge.in, value);
+    }
+  }
+}
+```

- Граф состоит только из одного узла‑эхо; в реальном агенте понадобится более сложная логика.  
- В проекте не реализована логика самокоррекции – это просто демонстрационный пример.  
-
-Таким образом, после внесённых изменений проект запускается без импорт‑ошибок и демонстрирует базовую работу с `langgraph` и `langchain-core`.
+**Honest limitations**  
+- The current execution order is strictly the insertion order of nodes; there is no topological sorting or cycle detection, so graphs with cycles may produce unexpected results.  
+- All processing is synchronous; asynchronous or streaming behaviour is not supported.  
+- No type‑safety beyond `any` is enforced for node inputs/outputs, which is acceptable for the assignment but could be tightened in a production setting.