Backend
engineering.
Applied AI.

A browser loads the Next.js interface through CloudFront and S3. Chat requests reach API Gateway and a Lambda-hosted FastAPI app through Mangum. The backend combines profile context and session history, calls Bedrock, stores the conversation, and returns the reply. A separate GitHub Actions workflow packages and provisions the AWS resources with Terraform.

• Visitor / browser: Professional profile questions. Message + session identifier.
• Next.js chat interface: Static frontend. Displays conversation replies.
• CloudFront + S3: CDN + static frontend bucket. Serves exported site assets.
• API Gateway: HTTP API · POST /chat. Forwards requests to Lambda.
• Lambda + FastAPI: Mangum adapter · chat handler. Load history · build prompt.
• Profile context: Facts · summary · style notes. LinkedIn document content.
• Conversation memory: S3 in AWS / local JSON files. Load history · save new turns.
• Amazon Bedrock: Converse API. Prompt + recent 50 messages.
• Chat response: Generated reply + session_id. Returned to the chat interface.
• GitHub Actions: OIDC AWS credentials. Runs deployment script.
• Build + package: Python Lambda ZIP. Next.js static export.
• Terraform + deployment: Lambda · API · S3 · CloudFront. Provision resources · upload.

• Visitor / browser → Next.js chat interface: open chat.
• CloudFront + S3 → Next.js chat interface: site assets.
• Next.js chat interface → API Gateway: message + session_id.
• API Gateway → Lambda + FastAPI: invoke handler.
• Profile context → Lambda + FastAPI: profile input.
• Lambda + FastAPI ↔ Conversation memory: session history.
• Lambda + FastAPI ↔ Amazon Bedrock: request / reply.
• Lambda + FastAPI → Chat response: response payload.
• Chat response → Next.js chat interface: HTTP response.
• GitHub Actions → Build + package: package.
• Build + package → Terraform + deployment: apply + upload.

The CLI loads configured filesystem MCP tools and a separate pytest tool, then starts a LangGraph workflow with message state. The model either finishes with a diagnosis and suggested fix or routes tool calls through ToolNode. Filesystem access and captured pytest output return as tool results for the next model step. A verified patch-and-rerun workflow remains future work.

• Debugging request: CLI prompt in main.py. Find bug · explain · suggest fix.
• Application entry point: Load MCP + pytest tools. Compile and invoke the graph.
• Codebase configuration: Settings.codebase_dir. Filesystem server directory.
• Message state: add_messages reducer. Request + model / tool history.
• Model node: OpenAI model with bound tools. Chooses tools or final response.
• Conditional routing: LangGraph tools_condition. Tool calls → tools; else finish.
• Diagnosis + suggestion: Final assistant message. Printed to the CLI.
• Tool execution: LangGraph ToolNode. Dispatch + return tool results.
• Target codebase: Source files and test suite. Configured local directory.
• Filesystem MCP server: stdio · npx filesystem server. Tools loaded through MCP client.
• pytest subprocess: uv run pytest · 60s timeout. Captured output + exit status.

• Debugging request → Application entry point: start.
• Codebase configuration → Application entry point: load settings.
• Application entry point → Model node: initial messages.
• Message state ↔ Model node: message history.
• Model node → Conditional routing: model output.
• Conditional routing → Tool execution: tool calls.
• Conditional routing → Diagnosis + suggestion: no tool calls → finish.
• Tool execution → Model node: tool results → next model step.
• Tool execution ↔ Filesystem MCP server: filesystem tool.
• Tool execution ↔ pytest subprocess: run_tests tool.
• Filesystem MCP server ↔ Target codebase: file access.
• pytest subprocess → Target codebase: execute tests in configured codebase.

Golden inputs and expected behavior feed evaluation runners. Separate support-agent, RAG-agent, and multi-turn chatbot paths exercise tools, policy retrieval, and conversation history. Agent and RAG callbacks capture traces; chatbot tests capture turns. Metric suites use this evidence and configured graders to produce per-case scores and reasons, with no benchmark result claimed here.

• Golden test cases: Order / refund / policy inputs. Small example datasets.
• Evaluation runners: Dataset evaluation iterator. Conversation evaluate().
• Expected behavior: Expected tool names. Reference answers for RAG.
• Support agent: LangChain + OpenAI. Instrumented tool-calling agent.
• RAG support agent: LangChain + OpenAI. search_policies tool.
• Multi-turn chatbot: OpenAI SDK tool loop. Keeps history between turns.
• Support tools: Order status + refund lookups. MCP shipping-options tool.
• Policy retrieval: 9 policies · OpenAI embeddings. InMemoryVectorStore · top 3.
• Conversation history: User / assistant messages. Tool calls and tool results.
• Captured evidence: Callbacks + observe → traces. Chat turns + retrieval context.
• OpenAI judge models: LLM-based metric grading. Used by configured metrics.
• DeepEval metric suites: Task / tools · RAG quality. Conversation quality.
• Evaluation output: Per-case scores + reasons. Configured metric thresholds.

• Golden test cases → Evaluation runners: test inputs.
• Expected behavior → Evaluation runners: expectations.
• Evaluation runners → Support agent: agent cases.
• Evaluation runners → RAG support agent: RAG cases.
• Evaluation runners → Multi-turn chatbot: conversation turns.
• Support agent ↔ Support tools: tool calls + results.
• RAG support agent ↔ Policy retrieval: semantic search.
• Multi-turn chatbot ↔ Conversation history: retain turns.
• Support agent → Captured evidence: model + tool spans.
• RAG support agent → Captured evidence: reply + context.
• Multi-turn chatbot → Captured evidence: captured turns.
• Captured evidence → DeepEval metric suites: actual + expected.
• DeepEval metric suites ↔ OpenAI judge models: LLM grading.
• DeepEval metric suites → Evaluation output: scores + reasons.