<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Box Developer Blog - Medium]]></title>
        <description><![CDATA[News and stories for working with the Box APIs - Medium]]></description>
        <link>https://medium.com/box-developer-blog?source=rss----a995c24848a3---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Box Developer Blog - Medium</title>
            <link>https://medium.com/box-developer-blog?source=rss----a995c24848a3---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 04:48:39 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/box-developer-blog" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Read the latest Box Developer stories on a new blog]]></title>
            <link>https://medium.com/box-developer-blog/read-the-latest-box-developer-stories-on-a-new-blog-2e03b413ceb5?source=rss----a995c24848a3---4</link>
            <guid isPermaLink="false">https://medium.com/p/2e03b413ceb5</guid>
            <category><![CDATA[developer]]></category>
            <category><![CDATA[content-strategy]]></category>
            <dc:creator><![CDATA[Olga Stefaniuk]]></dc:creator>
            <pubDate>Thu, 23 Apr 2026 11:25:49 GMT</pubDate>
            <atom:updated>2026-04-23T11:25:47.992Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vTUxDrFJr5gjf7nPJuUtag.png" /></figure><p>If you’ve been following us on Medium’s <a href="https://medium.com/box-developer-blog">Box Developer Blog</a>, you may have noticed we’ve been a bit quiet lately. That’s because our developer stories now have a new home.</p><p>All our tutorials, deep dives, and hands-on content live at <a href="https://blog.box.com/developer"><strong>blog.box.com/developer</strong></a>, right alongside the product announcements, integrations, and AI innovations shaping the Box Platform. Everything you loved about the Medium blog is there: the code walkthroughs, the real-world patterns for building on Box, and plenty more to come.</p><blockquote>If you’re a Japanese-speaking developer, translated stories are now published at <a href="https://japan.box.com/blog"><strong>japan.box.com/blog</strong></a>, so you can follow along in Japanese too. <em>🇯🇵</em></blockquote><h4>What’s already there</h4><p>Here’s a taste of what you’ll find at the new blog:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KywEJhD1LmMxLOMZ74Q0aA.png" /></figure><p><a href="https://blog.box.com/create-ai-e-signature-chatbot-box-sign-box-content-preview-and-copilotkit"><strong>Create an AI e-signature chatbot with Box Sign, Box Content Preview, and CopilotKit</strong></a><strong>. </strong>What if managing complex signature workflows was as simple as typing a sentence? This post walks through building a conversational AI interface that turns multi-step e-signature flows into natural language requests. Think: <em>“Send the job agreement to </em><a href="/service/mailto:alice@company.com"><em>alice@company.com</em></a><em> for approval, then </em><a href="/service/mailto:bob@company.com"><em>bob@company.com</em></a><em> to sign”</em> and it’s done, with a human-in-the-loop preview step built in. A great example of what’s possible when Box Sign, Box Content Preview, and open-source AI tooling come together.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1SyyK27hv68zGTZz0cbVVQ.png" /></figure><p><a href="https://blog.box.com/box-cli-content-cli-developers-and-agents"><strong>Box CLI: the content CLI for developers and agents</strong></a> The Box CLI just got a major upgrade, and it’s not just for developers anymore. This post introduces the next generation of the CLI, redesigned to work seamlessly with AI agents in the terminal. Whether you’re scripting content workflows, automating bulk operations, or building agents that interact with Box directly, this is the tool that makes it effortless.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1MAORXPo7YxZ18N81_kUOg.png" /></figure><p><a href="https://blog.box.com/teaching-ai-agents-work-your-content-building-box-skill-openai-codex"><strong>Teaching AI Agents to Work With Your Content: Building a Box Skill for OpenAI Codex</strong></a> What does it actually take to make an AI coding agent useful with enterprise content? This post introduces a Box Skill for OpenAI Codex, a structured knowledge package that teaches Codex how to authenticate, call the right endpoints, use Box AI to classify documents, and organize files at scale, all from a single natural-language prompt. A great read on the difference between giving an agent access to your content and teaching it to use that access well.</p><h4>Same community, new chapter</h4><p>Whether you’re a long-time reader or just discovering Box as a developer platform, you’re warmly welcome at the <a href="https://medium.com/blog.box.com/developer">new home</a>. The content is free, the code is open source, and the <a href="https://community.box.com/box-platform-5">Box Developer Community</a> is always open for questions, feedback, and sharing what you build.</p><p>Head over to <a href="https://blog.box.com/developer">blog.box.com/developer</a> and explore what’s new.</p><p><em>Thank you for being part of this journey. See you there!</em> 👋 ✨</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2e03b413ceb5" width="1" height="1" alt=""><hr><p><a href="https://medium.com/box-developer-blog/read-the-latest-box-developer-stories-on-a-new-blog-2e03b413ceb5">Read the latest Box Developer stories on a new blog</a> was originally published in <a href="https://medium.com/box-developer-blog">Box Developer Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Embed Box Hubs AI chat: set up intelligent conversational interface in Salesforce]]></title>
            <link>https://medium.com/box-developer-blog/embed-box-hubs-ai-chat-set-up-intelligent-conversational-interface-in-salesforce-cf6ccd3dd6c6?source=rss----a995c24848a3---4</link>
            <guid isPermaLink="false">https://medium.com/p/cf6ccd3dd6c6</guid>
            <category><![CDATA[sales-development]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[salesforce]]></category>
            <category><![CDATA[content-strategy]]></category>
            <category><![CDATA[rags]]></category>
            <dc:creator><![CDATA[Olga Stefaniuk]]></dc:creator>
            <pubDate>Fri, 06 Feb 2026 09:16:51 GMT</pubDate>
            <atom:updated>2026-02-06T09:16:50.440Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*23JOTA0typ62tq8XdRy_Dg.jpeg" /></figure><p>The embeddable Box Hubs AI Chat provides intelligent insights based on up to 20,000 files per hub. By including this iframe element directly into custom apps or portals like Salesforce, end users can ask questions, get advanced AI-generated answers without distractions, and leverage advanced LLMs from providers like OpenAI, Google, and Anthropic.</p><p>Think of this approach as giving your app a knowledgeable assistant that understands your company’s knowledge base, without the complexity of building and maintaining custom RAG systems or storing content in a vector database.</p><p>By following this guide, with just a few simple steps, you’ll have a complete RAG solution embedded in Salesforce using Box Hubs AI Chat, Visualforce, and Lightning App Builder.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*14EUaChcY8PDbpknMlVYIQ.gif" /></figure><p>As an example, consider an account executive at Acme Corporation who manages customer relationships in Salesforce. With Box Hubs AI Chat embedded on their account pages, they can ask questions like, “What marketing campaigns are planned for Q2?” or “What customer events are we hosting next quarter?” The AI instantly provides answers based on marketing plans, campaign briefs, and event documentation stored in the company’s Box Hub — all without leaving the Salesforce Account record.</p><p>Keep in mind that this use case can be further expanded with a tight integration between storing customer- and opportunity-related data in Box and by leveraging even more contextual insights.</p><h3>Box Hubs AI Chat in a nutshell</h3><p>Box Hubs AI Chat is an embeddable UI experience powered by the data within a specific Box Hub. Unlike <a href="https://medium.com/box-developer-blog/how-to-embed-box-hubs-in-custom-portals-293423f5ffb8">embedding a full Box Hub</a>, which includes navigation and file browsing, the AI Chat eliminates the need for browsing content and provides contextual answers from your organization’s documents in seconds.</p><p>This approach is perfect for use cases like:</p><ul><li><strong>Sales intelligence:</strong> Query competitive battle cards, product specifications, and pricing documentation directly from the Opportunity pages while you’re on customer calls.</li><li><strong>Support knowledge:</strong> Access troubleshooting guides and technical documentation from Case pages, getting instant answers to complex support questions.</li><li><strong>Account context:</strong> Query meeting notes, contracts, and project documentation from account pages, quickly gathering context before customer interactions.</li><li><strong>Product information:</strong> Access specifications, roadmaps, and research documentation embedded on custom product objects to instantly answer feature and timeline questions.</li><li><strong>Marketing insights:</strong> Get answers related to planned email and social media campaigns, customer-facing events, and conferences.</li></ul><p>The solution also includes AI models’ dropdown with LLMs from various providers and advanced thinking models. It comes in two embedding modes: full chat widget or the chat button, which opens on click.</p><h4>Chat Button mode</h4><p>The Chat Button mode adds a floating button to your page that opens the chat interface when clicked. It’s best for applications where you want chat to be available but not always visible.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/840/1*6kCmYKnf46nvUrUNWIr4gA.jpeg" /></figure><h4>Chat Widget Mode</h4><p>The Chat Widget mode embeds the full chat interface directly on your page using an iframe, displaying it immediately on page load. It’s best for dedicated help or support pages, knowledge base interfaces, or dashboard layouts with persistent panels.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VIJxzFOB0HqTVvGTAUs2-g.png" /></figure><p>In this tutorial we’re going to focus on embedding the chat widget on a Salesforce Lightning Experience in a few simple steps. No coding experience is required to complete this guide.</p><h4>Prerequisites</h4><p>Before starting the integration, ensure you have the following:</p><p><strong>Box Requirements:</strong></p><ul><li>Box AI for Hubs enabled at the enterprise level</li><li>At a minimum, viewer permissions on the Hub you plan to embed</li><li>Ability to generate a shared link to the Box Hub or Salesforce users added as collaborators on the Box Hub (via an email invitation)</li></ul><p><strong>Salesforce:</strong></p><ul><li>Lightning Experience enabled</li><li>Access to Setup with permission to create Visualforce pages</li><li>System Administrator or Customize Application permissions</li></ul><h3>Overview</h3><p>The integration involves four main steps:</p><ol><li>Preparing your Box Hub and copying the generated iframe code.</li><li>Creating a Visualforce page with the AI Chat iframe.</li><li>Configuring Salesforce security settings.</li><li>Adding the component to the Lightning record page.</li></ol><h3>Step 1: Generate the Box Hub embed code</h3><p>Let’s start with generating the iframe code in Box.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Io4hE185dHKFb9cal04GuA.png" /></figure><p>Navigate to your Box Hub and click the ellipsis menu in the upper-right corner. Select <strong>Embed</strong> from the dropdown menu.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/986/1*VXJ1xjaHA2HPYIYyfyNEzQ.png" /></figure><p>In the embed modal, select the <strong>Hub AI Chat</strong> tab. You’ll see two embedding options: <em>Chat button</em> and <em>Chat widget</em>. For this Salesforce integration, select the <em>Chat widget</em> mode, which displays the full chat interface directly on the page. You can modify the size to your needs with custom dimensions in pixels.</p><p>Box generates the iframe code snippet containing your Hub’s embed URL. Copy this code, as you’ll use it in the next step when creating the Visualforce page.</p><p>Here is an example snippet:</p><pre>&lt;iframe src=&quot;https://app.box.com/ai-chat?showCloseButton=false&amp;hubId=HUB_ID&amp;sharedLink=SHARED_LINK&quot; width=&quot;400&quot; height=&quot;600&quot; frameborder=&quot;0&quot; allowfullscreen webkitallowfullscreen msallowfullscreen allow=&quot;clipboard-read *; clipboard-write *&quot;&gt;&lt;/iframe&gt;</pre><h4>Managing user access</h4><p>For users to interact with the AI Chat, they must have access to the Box Hub and to Box AI features for Hubs. In case you wish to explicitly control users allowed to access the hub, remove the <strong>sharedLink</strong> parameter from the <strong>src</strong> URL and add your Salesforce users as collaborators by clicking the <em>Share</em> button in the top right of the Hub view, adding team members’ email addresses as collaborators and assigning appropriate permission levels. The viewer access is sufficient for AI Chat functionality.</p><h4>Alternative: Using Box for Salesforce Integration (Authenticated Access)</h4><p>For organizations requiring more sophisticated security features, the official Box for Salesforce integration from AppExchange provides authenticated access with seamless single sign-on and native Lightning components. This approach requires installing the Box for Salesforce package and configuring a Box service account, but offers enterprise-grade features like automated folder creation, Box Sign integration, and granular permission controls.</p><h3>Step 2: Create the Visualforce Page</h3><p>Now you’ll create a Visualforce page in Salesforce that embeds the Box Hubs AI Chat interface.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/441/1*c37PCGPocSfoeNQa9Azd_A.png" /></figure><p>Navigate to advanced settings by clicking the gear icon in the upper right corner and selecting <strong>Open Advanced Setup</strong>. A new browser window will open.</p><p>In the Quick Find search box on the left hand side, search for <em>Visualforce Pages</em> and select it from the results. Click <strong>New</strong> to create a new Visualforce page.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nVheuytJiR2zHWUjeekrKA.png" /></figure><p>Configure the page details and make sure you check the box for <strong>“Available for Lightning Experience, Experience Builder sites, and the mobile app”</strong>. This is an important step that will allow you to access this component from the Lightning Pages setup.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FyM2FDlbE7DbRkCEwwj0WA.png" /></figure><p>In the <strong>Visualforce Markup</strong> section, paste the following code structure, and replace the <em>src</em> value for the link generated in the Box Hub interface. You can also update the size of the page by adjusting the width and height.</p><pre>&lt;apex:page showHeader=&quot;false&quot; sidebar=&quot;false&quot;&gt;<br>  &lt;apex:iframe src=&quot;https://app.box.com/ai-chat?showCloseButton=false&amp;hubId=HUB_ID&amp;sharedLink=SHARED_LINK&quot;<br>   scrolling=&quot;false&quot;<br>   width=&quot;600&quot;<br>   height=&quot;600px&quot;<br>  /&gt;<br>&lt;/apex:page&gt;</pre><p>⚠️<em> Make sure you replace HUB_ID and YOUR_SHARED_LINK_HASH with the actual values from your Box Hub embed code.</em></p><p>Click <em>Save</em> and verify your AI Chat works in the preview mode.</p><h3>Step 3: Configure Salesforce Security Settings</h3><p>Salesforce requires explicit permission to load external content in iframes through Trusted URLs. Therefore, Box must be whitelisted before the Box Hubs AI Chat can be displayed within a Salesforce page.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sA3aryjurVclSvpa8WdEZA.png" /></figure><p>Navigate to <strong>Advanced</strong> <strong>Setup</strong> and search for Trusted URLs in the Quick Find box. Click New Trusted URL and configure the following:</p><ul><li><strong>Trusted Site Name:</strong> Box</li><li><strong>Trusted Site URL:</strong> <a href="https://app.box.com/">https://app.box.com</a></li><li><strong>Active:</strong> Checked</li><li><strong>Directives:</strong> Select all available contexts:</li><li><strong>connect-src</strong> (enables API calls)</li><li><strong>frame-src</strong> (enables iframe embedding)</li><li><strong>img-src</strong> (enables images)</li><li><strong>script-src</strong> (enables JavaScript)</li><li><strong>style-src</strong> (enables CSS styling)</li></ul><p>Once the above is complete, click Save.</p><h3>Step 4: Add AI Chat Component to Lightning Pages</h3><p>Lastly, we need to include the Visualforce Page containing the Box Hubs AI chat in a Lightning Page.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5fNVoLnvUEq6sxnJDgXXbA.png" /></figure><p>In order to do so, search for the <strong>Lightning App Builder </strong>in the <em>Quick Find</em> search bar. Pick the page where you want to include the component. In this example, we’ll be editing the Account Record Page. Let’s click this record and under the Lightning Page Detail record click Edit. A new editor experience will show up in the same browser window.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wOywW1gBUtiEu-99myJsvg.gif" /></figure><p>Pick a slot where you want to include the AI chat, and from the left hand side panel, choose <strong>Visualforce</strong>. In the right hand side panel, choose the component in the <strong>Visualforce Page Name</strong> select. You might want to alter the height to match the chat size defined in earlier steps. Once this is ready, click Save.</p><h4>Conclusion</h4><p>By embedding the Box Hubs AI Chat in Salesforce, you’ve created a seamless experience where users can leverage AI-powered document intelligence without leaving their workflow. This integration represents a powerful step toward making organizational knowledge more accessible and actionable.</p><p>We can’t wait to hear your feedback regarding this experience on our <a href="https://community.box.com/">Box Developer forum</a>.</p><h4>Additional Resources</h4><ul><li><a href="https://developer.box.com/guides/embed/box-embed/#box-hubs-ai-chat-embedding">Box Hubs AI Chat Embedding</a></li><li><a href="https://developer.salesforce.com/docs/atlas.en-us.pages.meta/pages/">Salesforce Visualforce Developer Guide</a></li><li><a href="https://help.salesforce.com/s/articleView?id=sf.lightning_app_builder_overview.htm">Lightning App Builder Guide</a></li><li><a href="https://help.salesforce.com/s/articleView?id=sf.csp_trusted_sites.htm">CSP Trusted Sites Documentation</a></li></ul><h4>Box Developer Blog — Salesforce Integration Series</h4><p>If you’d like to explore more possibilities of integrating Box and Salesforce, check out our Box Developer blog and articles dedicated to this area.</p><ul><li><a href="https://medium.com/box-developer-blog/getting-started-with-box-for-salesforce-development-part-1-824ab538ea13">Getting started with Box for Salesforce development: Part 1</a></li><li><a href="https://medium.com/box-developer-blog/getting-started-with-box-for-salesforce-development-part-2-e29848feefa6">Getting started with Box for Salesforce development: Part 2</a></li><li><a href="https://medium.com/box-developer-blog/box-salesforce-flow-tutorial-dbb782ac82a6">Box + Salesforce Flow Tutorial</a></li><li><a href="https://medium.com/box-developer-blog/box-salesforce-flows-with-metadata-c8979b02acb1">Box + Salesforce: Flows with metadata</a></li><li><a href="https://medium.com/box-developer-blog/box-salesforce-screen-flows-with-experience-cloud-7f440a65c9">Box + Salesforce: Screen Flows with Experience Cloud</a></li><li><a href="https://medium.com/box-developer-blog/box-salesforce-box-sign-writeback-flow-f4e050f2f60b">Box + Salesforce: Box Sign Writeback Flow</a></li><li><a href="https://medium.com/box-developer-blog/box-salesforce-flows-with-slack-integration-mappings-180e5a09e978">Box + Salesforce: Flows with Slack Integration Mappings</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cf6ccd3dd6c6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/box-developer-blog/embed-box-hubs-ai-chat-set-up-intelligent-conversational-interface-in-salesforce-cf6ccd3dd6c6">Embed Box Hubs AI chat: set up intelligent conversational interface in Salesforce</a> was originally published in <a href="https://medium.com/box-developer-blog">Box Developer Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Build a metadata extraction CLI with Box AI — using agents.md as your spec]]></title>
            <link>https://medium.com/box-developer-blog/build-a-metadata-extraction-cli-with-box-ai-using-agents-md-as-your-spec-5651ab7c463d?source=rss----a995c24848a3---4</link>
            <guid isPermaLink="false">https://medium.com/p/5651ab7c463d</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Andrew Wong]]></dc:creator>
            <pubDate>Thu, 29 Jan 2026 22:43:51 GMT</pubDate>
            <atom:updated>2026-01-29T22:43:50.663Z</atom:updated>
            <content:encoded><![CDATA[<h3>Build a metadata extraction CLI with Box AI — using agents.md as your spec</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Rlz0sbQ-TL-dEgrb2ivp2Q.jpeg" /></figure><p>Structured metadata is one of the most powerful layers in Box. It’s what powers search, filters, retention policies, automation, and downstream workflows. With Box AI, you can extract that structure directly from unstructured documents — invoices, contracts, forms — and apply it back to files in a repeatable way.</p><p>In this post, we’ll build a small Python CLI that does exactly that: it reads files from Box, extracts a known set of fields using <a href="https://developer.box.com/reference/post-ai-extract-structured">Box AI Extract Structured</a>, and writes those values back as <a href="https://developer.box.com/guides/metadata">Box metadata</a>.</p><p>The interesting part here isn’t the CLI itself; it’s how the workflow gets defined and brought to life.</p><p>Instead of driving the implementation with a long series of highly prescriptive prompts, we’ll rely on a single repository artifact — agents.md — to act as the contract between a developer and an AI coding assistant.</p><h3>What we’re building</h3><p>The goal here isn’t to hand-write a CLI from scratch. Instead, we’re using a small Python CLI as a concrete way to run a metadata extraction workflow end to end.</p><p>The CLI itself is intentionally simple; it exists to orchestrate a repeatable flow that reads files from Box, extracts a predefined set of fields using Box AI Extract Structured, and writes those values back to the file as Box metadata.</p><p>Once the project is in place, you can run the workflow from the repository root, for example:</p><pre>1 python -m src.cli run --file-id 12345 --template-key invoiceMetadata --dry-run<br>2 python -m src.cli run --folder-id 67890 --template-key invoiceMetadata</pre><p>In practice, this lets you point the CLI at a folder of documents — for example, a batch of invoices — and have metadata extracted and written back across all files using the same underlying logic. The rest of this post focuses on how that workflow is defined and brought to life, rather than on manually authoring each line of code.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2F8EC0wntnCHU%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3D8EC0wntnCHU&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2F8EC0wntnCHU%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="640" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/4642adff38f78a5649673fce65867afa/href">https://medium.com/media/4642adff38f78a5649673fce65867afa/href</a></iframe><h3>Why agents.md?</h3><p>If you’ve worked with AI coding tools, you’ve probably noticed that the quality of the output depends less on the cleverness of the prompt than on the clarity of the constraints.</p><p>An agents.md file is a simple way to put those constraints <em>in the repository itself</em>, instead of re-explaining them every time you open a chat. Think of it as a lightweight, human-readable spec that describes what the project should do, how it’s structured, what’s allowed, and what “done” looks like.</p><p>In this project, agents.md defines things like the expected CLI interface, the authentication method, the SDK import paths that must be used, and even the exact step-by-step output the CLI should print on a successful run. That allows the prompt to stay high level, while the specificity lives alongside the code where it belongs.</p><p>You don’t need to adopt agents.md to follow this tutorial. What matters is the idea behind it: that when a repository clearly defines its own shape and constraints, AI-assisted development becomes more predictable, easier to review, and easier to extend.</p><h3>Architecture overview</h3><p>At a high level, the workflow looks like this:</p><pre>CLI (argparse)<br>  → Box client (CCG auth via env)<br>    → Box AI Extract Structured (per file)<br>      → normalize fields into plain dict<br>        → Box metadata (create/update instance)</pre><p>The CLI is mostly orchestration glue. The real value comes from treating extract → normalize → write metadata as a stable primitive, and keeping everything else thin.</p><h3>Prerequisites</h3><p>Before beginning, you’ll need:</p><ul><li>A <a href="https://developer.box.com/guides/applications">Box app</a> configured for <a href="https://developer.box.com/guides/authentication/client-credentials">Client Credentials Grant (CCG)</a>. The app has access to the content you want to process (enterprise settings / scopes)</li><li><a href="https://support.box.com/hc/en-us/articles/22166647877011-Configuring-Box-AI">Box AI enabled</a> for your enterprise</li><li>A <a href="https://developer.box.com/guides/search/quick-start/create-metadata-template">metadata template</a> in Box (i.e., the schema you want to populate)</li></ul><p>If you’ve never used metadata templates before, think of the template as the schema for the fields you want Box AI to extract.</p><p>For testing, it also helps to have a folder with a few representative documents (invoices, receipts, or contracts) so you can see consistent output.</p><h3>The starting point: agents.md</h3><p>At the beginning, the repository is intentionally minimal. There’s no scaffolding, no Python package, and no CLI code yet. There is exactly one meaningful artifact: agents.md.</p><p>That file acts as the source of truth for the entire project. Instead of describing the implementation step by step in a prompt, it captures the decisions that <em>don’t change</em> from run to run — the things you’d normally find yourself re-explaining every time you generate or revise the code.</p><p>Concretely, agents.md pins down details like:</p><ul><li>which SDK must be used (box-sdk-gen)</li><li>the authentication model (CCG, via environment variables)</li><li>how the CLI is invoked (python -m src.cli run ...)</li><li>the shape of the project (which files exist and what each one owns)</li><li>exact schema imports for Box AI Extract Structured, including which imports to avoid</li></ul><p>Those constraints are what make the rest of this workflow predictable. The coding assistant isn’t inferring structure from a vague description — it’s implementing a spec that lives alongside the code.</p><p><a href="https://github.com/box-community/box-metadata-extract-and-tag/blob/main/agents.md">The full </a><a href="https://github.com/box-community/box-metadata-extract-and-tag/blob/main/agents.md">agents.md is available in the repo</a>, but you don’t need to read it line by line to follow along. What matters is that at this point, it’s the <em>only</em> input we start from — and it’s specific enough to produce a complete, runnable project.</p><h3>Run a single prompt</h3><p>With agents.md in place, we give the coding assistant a single instruction:</p><blockquote>Use agents.md as the guide and build a small CLI app that extracts information from documents in Box using Box AI and writes it back as metadata</blockquote><p>That’s it.</p><p>The prompt is short because the intent and constraints are already encoded in the repo. There’s no need to spell out file names, module boundaries, CLI flags, or even tricky SDK import paths — those decisions were already encoded in agents.md. The assistant isn’t “guessing what I meant;” it’s implementing a spec that lives right next to the code.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*S0_Jnax4TW-jV4N13vFjPw.avif" /></figure><h3>Project layout</h3><p>After the prompt completes, the repo now has a working project:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*h4ZCtWQktIUtvgt9hZl6jg.avif" /></figure><p>Here’s what the repo looks like after the prompt runs:</p><pre>.<br>├── agents.md<br>├── README.md<br>├── .env.example<br>├── requirements.txt<br>└── src/<br>    ├── __init__.py<br>    ├── cli.py<br>    ├── box_client.py<br>    ├── extract.py<br>    └── metadata.py</pre><p>Each module has a single responsibility. One handles environment loading and CCG authentication. Another owns structured extraction and normalization. Another writes metadata back to Box. Then the CLI wires all those pieces together.</p><p>This separation keeps the code easy to reason about and makes batch processing a thin layer on top of the single-file path.</p><h3>Set up and run the CLI</h3><p>Now that the project exists, you can run it like any other small Python tool.</p><h3>Create a virtual environment and install dependencies:</h3><pre>python -m venv .venv<br>source .venv/bin/activate<br>pip install -r requirements.txt</pre><p>The dependency surface area is intentionally small; just the Box Generated Python SDK and python-dotenv.</p><p>Next, copy the example environment file:</p><pre>cp .env.example .env</pre><p>Fill in your Box credentials (BOX_CLIENT_ID, BOX_CLIENT_SECRET, BOX_ENTERPRISE_ID). You can also set defaults for the metadata template key, scope, and AI model if you want to avoid passing them on every run.</p><h3>Run the extraction workflow</h3><p>With the environment configured, you can run the extraction workflow against an entire folder of documents.</p><pre>python -m src.cli run --folder-id &lt;FOLDER_ID&gt; --template-key invoice</pre><p>The CLI will authenticate using Client Credentials Grant, iterate through the files in the folder, extract structured fields using Box AI, and write those values back as metadata on each file.</p><p>You’ll see step-labeled output as the run progresses, including per-file status and any errors encountered along the way.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*drvb9POddFtoJThl_gJ6gw.avif" /></figure><p>Each file is processed independently. Errors on one file don’t stop the run, which makes this suitable for real-world folders where documents may vary in quality or format.</p><p>Under the hood, every file follows the same extract → normalize → write flow. Folder execution is simply orchestration on top of that primitive.</p><h3>Key takeaways</h3><p>A few things are worth calling out after building this:</p><ul><li>Short prompts work when the repo carries the specificity.</li><li>agents.md works best when it’s prescriptive about structure and interfaces, not implementation details.</li><li>The reusable primitive here is extract → normalize → write metadata; everything else is orchestration.</li><li>Keeping the dependency surface area small makes tools like this easier to trust and share.</li></ul><p>This pattern isn’t limited to Box or metadata extraction; any workflow with a stable core and flexible inputs can benefit from the same approach. When you put the constraints in the repo, you get something you can regenerate, review, and evolve — and the assistant becomes a much more reliable collaborator.</p><h3>Where to go next</h3><p>From here, it’s easy to extend the CLI in pragmatic ways: selective writes, CSV summaries, retry logic, or deeper validation. The important part is that the foundation stays stable.</p><p>Once the repository knows what it is, the AI doesn’t need to be told very much at all.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5651ab7c463d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/box-developer-blog/build-a-metadata-extraction-cli-with-box-ai-using-agents-md-as-your-spec-5651ab7c463d">Build a metadata extraction CLI with Box AI — using agents.md as your spec</a> was originally published in <a href="https://medium.com/box-developer-blog">Box Developer Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building a reusable metadata extraction Agent Skill with Box MCP and Box AI]]></title>
            <link>https://medium.com/box-developer-blog/building-a-reusable-metadata-extraction-agent-skill-with-box-mcp-and-box-ai-5d5f149f2e82?source=rss----a995c24848a3---4</link>
            <guid isPermaLink="false">https://medium.com/p/5d5f149f2e82</guid>
            <category><![CDATA[mcp-server]]></category>
            <category><![CDATA[metadata]]></category>
            <category><![CDATA[agent-skills]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Andrew Wong]]></dc:creator>
            <pubDate>Fri, 23 Jan 2026 03:56:13 GMT</pubDate>
            <atom:updated>2026-01-23T08:35:33.987Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vMnfCtzrk7Vi0J5x1tukDA.png" /></figure><p>Extracting metadata from documents is a common task. In Box, metadata like IDs, invoices, contracts, forms, and more often underpins search, automation, retention, and downstream workflows.But populating it at scale can be time-consuming.</p><p>In this post, we’ll walk through a template-driven Agent Skill that reads files directly from a Box folder, extracts structured values using <a href="https://developer.box.com/guides/box-ai">Box AI</a>, and writes those values back as <a href="https://developer.box.com/guides/metadata">Box metadata</a> — while keeping the files in Box as the system of record that continues to drive search, automation, and downstream workflows.</p><h3>What is an Agent Skill?</h3><p>An <a href="https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview">Agent Skill</a> is a portable, declarative way to define what an agent knows how to do.</p><p>Instead of encoding a workflow in a long prompt or repeating instructions across projects, an Agent Skill packages a capability — such as “extract metadata from Box files and write it back” — into a reusable definition (SKILL.md) that can be installed into an agent environment.</p><p>To interact with real systems like Box, the skill in this demo relies on <a href="https://www.box.com/mcp-server">MCP (Model Context Protocol)</a>, which exposes files, metadata, and Box AI as tools the agent can call directly. This allows the workflow to be defined declaratively, without writing API clients or wiring requests by hand.</p><p>In practice, the workflow is defined once in a structured way. The skill orchestrates tools like MCP and Box AI, and the same capability can be reused across folders, schemas, and projects.</p><p>Once installed, using a skill often looks like a single command:</p><blockquote>Use the box-metadata-extraction skill on the Box folder with ID &lt;FOLDER_ID&gt; using metadata template key &lt;TEMPLATE_KEY&gt;.</blockquote><p>The agent handles the orchestration; the skill defines the rules.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FjchopNSEITQ%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DjchopNSEITQ&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FjchopNSEITQ%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="640" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/f1e70a2b60698100935c8fb171da6202/href">https://medium.com/media/f1e70a2b60698100935c8fb171da6202/href</a></iframe><h3>Why this matters for metadata workflows</h3><p>In Box, <a href="https://developer.box.com/guides/metadata">metadata</a> lets you attach structured fields (defined by <a href="https://developer.box.com/guides/metadata/templates">metadata templates</a>) to files and folders. These fields, such as invoice number, vendor, or expiration date, become first-class data that can be searched, automated, and accessed via APIs.</p><p>Because metadata is schema-driven, extraction workflows tend to be repeatable. The same steps apply each time: identify the target files, extract a known set of fields, and write values back safely without overwriting existing data.</p><p>This makes metadata extraction a natural fit for Agent Skills. By pairing Agent Skills with MCP, you can encode this workflow once — without writing API glue code — and reuse it across folders, document types, and metadata templates. The template defines what to extract, the skill defines how to do it safely, and MCP handles interaction with Box behind the scenes.</p><p>The result is a workflow that’s easier to reuse, safer to rerun, and easier to reason about as metadata becomes a foundation for search, automation, and downstream systems.</p><h3>Architecture overview</h3><p>At a high level, the workflow looks like this:</p><pre>Agent (Cursor)<br>  → Agent Skill (SKILL.md)<br>      → Box MCP<br>          → Box AI (structured extraction)<br>          → Box Metadata (read/write)</pre><p>The agent orchestrates the process, Box remains the system of record, and MCP exposes Box capabilities as tools the agent can call.</p><h3>Prerequisites</h3><p>Before running the skill, make sure you have:</p><ol><li><a href="https://github.com/box-community/mcp-server-box">Box MCP server</a> running in Cursor (tools visible)</li><li><a href="https://developer.box.com/guides/search/quick-start/create-metadata-template">A Box metadata template</a> (template_key preferred)</li><li><a href="https://support.box.com/hc/en-us/articles/360044196633-Upload-to-Box-With-the-File-Browser">A Box folder with files</a> (top-level only)</li></ol><h3>Installing the Agent Skill</h3><p>From the repo root:</p><pre>npx ai-agent-skills install ./box-metadata-extraction --agent cursor</pre><p>Restart Cursor after installing so the skill is loaded.</p><h3>Defining the skill (SKILL.md)</h3><p>The behavior of the workflow is defined declaratively in SKILL.md. Rather than walking through the full file, here are the the key technical characteristics of the skill:</p><ul><li>Template-driven extraction: The skill takes a Box metadata template (by key or name) as input and uses that schema to determine exactly which fields to extract. No document-specific logic is hardcoded.</li><li>MCP-based Box access: All interactions with Box — listing folder contents, extracting content with Box AI, and reading or writing metadata — are performed via Box MCP tools. No custom API clients or glue code are required.</li><li>Safe metadata writes: Before writing metadata, the skill checks for an existing metadata instance and only fills fields that are currently empty. Existing values are never overwritten.</li><li>Box-native processing: Documents remain in Box throughout the workflow. Files are not downloaded or persisted locally, and Box remains the system of record for both content and metadata.</li></ul><p><a href="https://github.com/box-community/box-mcp-agent-skill-metadata-extraction/blob/main/box-metadata-extraction/SKILL.md">You can view the full skill definition on GitHub</a>. The complete SKILL.md is also included later in this post for reference.</p><h3>Running the skill in Cursor</h3><p>Once installed, invoke the skill directly from a Cursor chat.</p><h3>Start with a dry run</h3><p>This validates access and extraction logic without writing anything:</p><blockquote>Use the box-metadata-extraction skill on the Box folder with ID &lt;FOLDER_ID&gt; using metadata template key &lt;TEMPLATE_KEY&gt;. dry_run=true limit=1</blockquote><p>Expected behavior:</p><ul><li>Box MCP tools are called (list files, load template, extract values)</li><li>Cursor returns a summary of what <em>would</em> be written</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AWVNp2phkNeiRGH1PJojOQ.png" /></figure><h3>Write metadata for a single file</h3><p>When the dry run looks correct:</p><blockquote>Use the box-metadata-extraction skill on the Box folder with ID &lt;FOLDER_ID&gt; using metadata template key &lt;TEMPLATE_KEY&gt;. dry_run=false limit=1</blockquote><p>This updates metadata for exactly one file in the folder, which is useful for validating behavior before running at scale.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uihQkB9KZ_C-w-it92CWsg.png" /></figure><p>After validating the results on a single file, simply remove the limit parameter to run the workflow across the entire folder. The same extraction and write-back logic will be applied consistently to each top-level file.</p><h3>Verifying results in Box</h3><p>Open the processed file in Box and expand the Metadata panel. You should see:</p><ul><li>the metadata template applied</li><li>extracted fields populated</li><li>fields without values left blank</li><li>any pre-existing values unchanged</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ch3Vuc1OZ5h8EgllKxhLlQ.png" /></figure><h3>Full skill definition (SKILL.md)</h3><p>Below is the complete SKILL.md used in this walkthrough.</p><pre># Box Metadata Extraction - Template-Driven (Box MCP)</pre><pre>## Purpose<br>Extract structured metadata from documents stored in a Box folder and write it back using a specified Box metadata template.</pre><pre>This skill is designed to be reusable across document types by taking a `template_key` as input and using Box AI + Box metadata tools to populate metadata instances on each file.</pre><pre>---</pre><pre>## When to Use<br>Use this skill when you want to:<br>- Populate Box metadata for all files in a folder<br>- Reuse one workflow across many document types<br>- Drive extraction from an existing Box metadata template (by key or name)</pre><pre>Example prompts:<br>- “Use the box-metadata-extraction skill on the Box folder with ID &lt;FOLDER_ID&gt; using metadata template key identifications.”<br>- “Use the box-metadata-extraction skill on this Box folder shared link &lt;URL&gt; using metadata template name identifications.”</pre><pre>---</pre><pre>## Inputs</pre><pre>### Required<br>Provide ONE of:<br>- **folder_id** (string), OR<br>- **folder_shared_link_url** (string)</pre><pre>And ONE of:<br>- **template_key** (string), OR<br>- **template_name** (string)</pre><pre>### Optional<br>- **dry_run** (boolean, default: false)  <br>  If true, do not write metadata back to Box. Only report what would be written.</pre><pre>- **limit** (number)  <br>  Maximum number of files to process (useful for demos).</pre><pre>- **use_enhanced_extraction** (boolean, default: false)  <br>  If true, prefer enhanced Box AI extraction for harder scans.</pre><pre>---</pre><pre>## Guardrails (Hard Rules)<br>- Documents are stored only in Box. Do not rely on local document files.<br>- Do not recurse into subfolders (top-level files only).<br>- Do not overwrite existing metadata values: fill empty fields only.<br>- Avoid downloading and saving files locally (do not call file download with saving enabled).</pre><pre>---</pre><pre>## Tooling (What to Use)<br>Use these Box MCP tools as needed:</pre><pre>### Resolve folder and list files<br>- `box_shared_link_folder_find_by_shared_link_url_tool` (if using a folder shared link)<br>- `box_folder_items_list_tool` (list top-level items; keep `is_recursive=false`)  </pre><pre>### Read file content (only if needed for fallback)<br>- Prefer `box_file_text_extract_tool` to extract readable text/markdown from a file</pre><pre>### Load template schema (optional but recommended)<br>- `box_metadata_template_get_by_key_tool` (preferred)<br>- `box_metadata_template_get_by_name_tool` (fallback)</pre><pre>### Extract structured data<br>- `box_ai_extract_structured_using_template_tool` (preferred)<br>- `box_ai_extract_structured_enhanced_using_template_tool` (if `use_enhanced_extraction=true`)</pre><pre>### Read/write metadata instances<br>- `box_metadata_get_instance_on_file_tool`<br>- `box_metadata_set_instance_on_file_tool` (if no instance exists)<br>- `box_metadata_update_instance_on_file_tool` (update only empty fields)</pre><pre>---</pre><pre>## Workflow</pre><pre>### Step 1 — Resolve the target folder<br>If `folder_id` is provided:<br>- Use it directly.</pre><pre>If `folder_shared_link_url` is provided:<br>- Resolve the folder using `box_shared_link_folder_find_by_shared_link_url_tool`.<br>- Use the returned folder id.</pre><pre>### Step 2 — List top-level files<br>- Call `box_folder_items_list_tool(folder_id, is_recursive=false)`.<br>- Filter results to files only.<br>- If `limit` is provided, process only the first N files.</pre><pre>### Step 3 — Resolve template key (if only name provided)<br>- If `template_key` is provided, use it.<br>- Else look up the template using `box_metadata_template_get_by_name_tool(template_name)` and extract its key.</pre><pre>(Optionally) fetch template definition using `box_metadata_template_get_by_key_tool` to learn field names/types for normalization.</pre><pre>### Step 4 — For each file, check existing metadata<br>- Call `box_metadata_get_instance_on_file_tool(file_id, template_key)`.<br>- Determine which template fields are already populated.<br>- Only attempt to fill missing/empty fields.</pre><pre>### Step 5 — Extract structured data for this file<br>Preferred path:<br>- Call Box AI template extraction for this file:<br>  - `box_ai_extract_structured_using_template_tool(file_ids=[file_id], template_key=template_key)`<br>  - If `use_enhanced_extraction=true`, use the enhanced variant.</pre><pre>Fallback path (only if template extraction fails or returns empty):<br>- Use `box_file_text_extract_tool(file_id)` to retrieve text.<br>- Then extract only template-defined fields.</pre><pre>---</pre><pre>### Step 6 — Normalize and filter extracted values<br>- Normalize dates to `YYYY-MM-DD` when possible.<br>- Trim whitespace.<br>- Preserve casing for names and proper nouns.</pre><pre>**Important:**<br>- If a value does not exist in the document, **do not write anything** for that field.<br>- Do not invent, infer, or synthesize values.<br>- Only include fields with non-empty values that are clearly supported by the document content.</pre><pre>---</pre><pre>### Step 7 — Write metadata back (unless dry_run)<br>- Build `metadata_values` using only fields that:<br>  1) were extracted with a real, non-empty value, AND<br>  2) are currently empty on the file.</pre><pre>If no metadata instance exists:<br>- Use `box_metadata_set_instance_on_file_tool(file_id, template_key, metadata_values)`</pre><pre>If an instance exists:<br>- Use `box_metadata_update_instance_on_file_tool(file_id, template_key, metadata_values)`</pre><pre>Never overwrite existing non-empty fields.</pre><pre>---</pre><pre>### Step 8 — Output summary<br>Return a summary table showing:<br>- file name<br>- file id<br>- template_key<br>- fields written (with full values)<br>- fields skipped (already present or not found)</pre><pre>Do not redact values in the summary output.</pre><pre>---</pre><pre>## Failure Handling<br>- If one file fails, continue with the remaining files and report the error.<br>- If the template cannot be resolved, stop and explain what is required.<br>- If extraction yields no values for a file, report “no data extracted” and continue.</pre><pre>---</pre><pre>## Expected Output<br>- Full metadata values written to Box for extracted fields<br>- Clear visibility of extracted values in both chat output and Box UI<br>- No local document files required</pre><p>You don’t need to edit this to use the skill. It’s included here so the behavior is explicit and easy to adapt.</p><h3>Why template-driven skills scale well</h3><p>Once the skill is installed, the same workflow can be reused simply by changing its inputs: the Box folder that contains the files and the metadata template that defines the schema.</p><p>Because the skill is template-driven, it doesn’t need to know anything about the document type ahead of time. The metadata template determines which fields are extracted, and the skill applies the same safe extraction logic regardless of whether the files are invoices, contracts, IDs, or other documents.</p><p>This makes the workflow easy to reuse across teams and use cases. You can point the same skill at different folders and templates without rewriting prompts, duplicating logic, or creating document-specific variants. The behavior stays consistent; only the inputs change.</p><h3>Repository and next steps</h3><p>GitHub repo: <a href="https://github.com/box-community/box-mcp-agent-skill-metadata-extraction">https://github.com/box-community/box-mcp-agent-skill-metadata-extraction</a></p><p>From here, you might:</p><ul><li>add review or approval steps before writing metadata</li><li>introduce folder recursion for deeper hierarchies</li><li>chain this skill with others</li></ul><p>Agent Skills make it easier to turn repeatable content workflows into reusable building blocks — especially when paired with Box MCP and Box AI.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5d5f149f2e82" width="1" height="1" alt=""><hr><p><a href="https://medium.com/box-developer-blog/building-a-reusable-metadata-extraction-agent-skill-with-box-mcp-and-box-ai-5d5f149f2e82">Building a reusable metadata extraction Agent Skill with Box MCP and Box AI</a> was originally published in <a href="https://medium.com/box-developer-blog">Box Developer Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building systems with Langchain deep agents and Box]]></title>
            <link>https://medium.com/box-developer-blog/building-systems-with-langchain-deep-agents-and-box-42e6afc62dbb?source=rss----a995c24848a3---4</link>
            <guid isPermaLink="false">https://medium.com/p/42e6afc62dbb</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[box]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Rui Barbosa]]></dc:creator>
            <pubDate>Thu, 22 Jan 2026 12:02:17 GMT</pubDate>
            <atom:updated>2026-01-22T12:02:16.841Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZdLY8TW1bkTJU3VXl15tFA.png" /></figure><p>Let’s be honest: most AI agent frameworks are a tangled mess of prompt engineering, state management, and hope. You start with “this will automate our workflow!” and end up with a brittle system that falls apart when someone sneezes.</p><p><strong>Deep Agents</strong> (from LangChain) is different. It’s an orchestrator-based framework that actually makes sense. And to prove it, I built an auto loan underwriting system that coordinates document extraction, policy interpretation, and risk calculation — without descending into chaos.</p><p>Here’s what we’ll cover:</p><ul><li><strong>Deep Agents framework</strong> — orchestrators, sub-agents, and memory (the stuff that matters)</li><li><strong>Real implementation</strong> — auto loan underwriting with actual code</li><li><strong>Box AI integration</strong> — document intelligence without the API wrestling</li></ul><h3>The deep agents mental model</h3><p>Before we dive into code, here’s the framework in three concepts:</p><h4>Orchestrators own the workflow</h4><p>The <strong>orchestrator</strong> is your main agent. It doesn’t try to do everything — it coordinates. Think of it as a project manager who delegates to specialists rather than trying to write code, design UI, and deploy infrastructure simultaneously.</p><pre># The orchestrator&#39;s job:<br># 1. Understand the request<br># 2. Break it into tasks<br># 3. Delegate to sub-agents<br># 4. Synthesize the results<br># 5. Make the final decision</pre><p>The orchestrator has its own tools (usually high-level ones like “upload reports”), but it doesn’t have access to every tool in the system. That’s intentional.</p><h4>Sub-agents are specialists</h4><p>Each <strong>sub-agent</strong> is laser-focused on one thing. They have:</p><ul><li><strong>Isolated context</strong> — can’t see the orchestrator’s full state</li><li><strong>Specialized tools</strong> — only what they need for their job</li><li><strong>Single responsibility</strong> — extract data, calculate risk, interpret policy, etc.</li></ul><p>Sub-agents can’t call other sub-agents. They do their work and return findings to the orchestrator. This isolation prevents the “everything talks to everything” spaghetti that kills most agent systems.</p><h4>Memory is persistent and routed</h4><p>Deep Agents supports <strong>composite backends</strong> — different types of storage for different needs:</p><pre>CompositeBackend(<br>    default=StateBackend(rt),              # Ephemeral conversation state<br>    routes={<br>        &quot;/memories/&quot;: FilesystemBackend()  # Persistent decision reports<br>    }<br>)</pre><p>Agents write to virtual paths like /memories/Sarah_Chen/risk_calculation.md, which map to actual files. This gives you an audit trail of every decision, calculation, and data extraction - critical for regulated industries.</p><h3>Implementation of an auto loan underwriting</h3><p>Let’s build something that matters. Auto loan underwriting requires:</p><ol><li><strong>Document extraction</strong> — pull data from PDFs (applications, credit reports, pay stubs)</li><li><strong>Policy interpretation</strong> — understand underwriting rules and thresholds</li><li><strong>Risk calculation</strong> — compute DTI, LTV, identify violations</li><li><strong>Decision synthesis</strong> — make the approve/deny/escalate call</li></ol><p>This is a perfect fit for Deep Agents because each step requires different expertise and tools.</p><h4>Orchestrator setup</h4><p>Here’s how we create the orchestrator in <a href="https://github.com/box-community/langchain-box-loan-demo/blob/main/src/agents/loan_orchestrator.py">loan_orchestrator.py</a>:</p><pre>from deepagents import create_deep_agent<br>from deepagents.backends import (<br>  CompositeBackend, <br>  FilesystemBackend, <br>  StateBackend,<br>)<br><br>def loan_orchestrator_create(applicant_name: str) -&gt; CompiledStateGraph:<br>    # Define three specialized sub-agents<br>    sub_agents = [<br>        {<br>            &quot;name&quot;: &quot;box-extract-agent&quot;,<br>            &quot;description&quot;: &quot;Retrieves and extracts data from loan documents in Box&quot;,<br>            &quot;system_prompt&quot;: BOX_EXTRACT_AGENT_INSTRUCTIONS,<br>            &quot;tools&quot;: [<br>                search_loan_folder,      # Find the applicant&#39;s folder<br>                list_loan_documents,     # List all files<br>                ask_box_ai_about_loan,   # Query documents with natural language<br>                extract_structured_loan_data,  # Extract specific fields<br>                think_tool,              # Strategic reflection<br>            ],<br>        },<br>        {<br>            &quot;name&quot;: &quot;policy-agent&quot;,<br>            &quot;description&quot;: &quot;Interprets underwriting policies and rules&quot;,<br>            &quot;system_prompt&quot;: POLICY_AGENT_INSTRUCTIONS,<br>            &quot;tools&quot;: [<br>                ask_box_ai_about_loan,   # Query policy documents<br>                think_tool,<br>            ],<br>        },<br>        {<br>            &quot;name&quot;: &quot;risk-calculation-agent&quot;,<br>            &quot;description&quot;: &quot;Performs quantitative risk analysis&quot;,<br>            &quot;system_prompt&quot;: RISK_CALCULATION_AGENT_INSTRUCTIONS,<br>            &quot;tools&quot;: [<br>                calculate,               # Safe math evaluation<br>                think_tool,<br>            ],<br>        },<br>    ]<br>    <br>    # Configure persistent memory<br>    filesystem_backend = FilesystemBackend(<br>        root_dir=str(memories_folder),<br>        virtual_mode=True,<br>    )<br>    <br>    def backend(rt):<br>        return CompositeBackend(<br>            default=StateBackend(rt),<br>            routes={<br>                &quot;/memories/&quot;: filesystem_backend,<br>            },<br>        )<br>    <br>    # Create the orchestrator<br>    agent = create_deep_agent(<br>        model=init_chat_model(&quot;anthropic:claude-sonnet-4-5-20250929&quot;, temperature=0.0),<br>        tools=[upload_text_file_to_box],  # Orchestrator only uploads final reports<br>        system_prompt=LOAN_ORCHESTRATOR_INSTRUCTIONS,<br>        subagents=sub_agents,<br>        backend=backend,<br>    )<br>    <br>    return agent</pre><p><strong>Key points:</strong></p><ul><li>Each sub-agent gets <strong>exactly the tools it needs</strong> — no more, no less</li><li>The orchestrator only has upload_text_file_to_box() - it doesn&#39;t extract data or calculate risk</li><li>Memory routing sends reports to /memories/ which persists to disk</li><li>Temperature is 0.0 for deterministic decisions (critical for financial applications)</li></ul><h4>Workflow (from the Orchestrator’s prompt)</h4><p>The orchestrator’s system prompt (<a href="https://github.com/box-community/langchain-box-loan-demo/blob/main/src/agents/loan_underwriting/loan_prompts.py">loan_prompts.py</a>) defines the workflow:</p><pre>LOAN_ORCHESTRATOR_INSTRUCTIONS = &quot;&quot;&quot;<br>You orchestrate the loan underwriting workflow by delegating to specialists.<br><br>## Workflow Steps<br>1. **Clean up**: Delete old files in `/memories/{applicant_name}/`<br>2. **Document Extraction**: Delegate to box-extract-agent<br>3. **Policy Retrieval**: Delegate to policy-agent for thresholds<br>4. **Risk Calculation**: Delegate to risk-calculation-agent for DTI/LTV<br>5. **Make Recommendation**: Synthesize findings, make decision<br>6. **Write Report**: Comprehensive report to `/memories/{applicant_name}/`<br>7. **Upload to Box**: Upload all reports back to applicant&#39;s folder<br><br>## Decision Framework<br>Your final recommendation must be one of:<br>- AUTO-APPROVE ✅ (zero violations, credit ≥700, DTI ≤40%)<br>- HUMAN REVIEW ⚠️ (1-2 minor violations, requires senior underwriter)<br>- ESCALATION REQUIRED 🚨 (moderate violations, regional director approval)<br>- AUTO-DENY 🚫 (major violations, unacceptable risk)<br>&quot;&quot;&quot;</pre><p>The orchestrator doesn’t know <em>how</em> to extract data or calculate DTI — it just knows <em>when</em> to delegate and <em>what</em> to do with the results.</p><h4>Box AI Integration</h4><p>Here’s where Box AI comes in as the document intelligence layer. Instead of manually parsing PDFs and wrestling with document structure, we use Box’s AI capabilities through the box-ai-agents-toolkit.</p><p><strong>The toolkit includes 150+ functions</strong> organized into:</p><ul><li><strong>Box AI</strong> (Ask, Extract, Agent management)</li><li><strong>File/Folder Operations</strong> (CRUD, metadata, tags)</li><li><strong>Search</strong> (content search, folder location)</li><li><strong>Collaboration</strong> (sharing, permissions, groups)</li><li><strong>Enterprise Features</strong> (tasks, DocGen, metadata templates)</li></ul><p>For this demo, we use <strong>5 key functions</strong> wrapped as LangChain tools in <a href="https://github.com/box-community/langchain-box-loan-demo/blob/main/src/agents/loan_underwriting/loan_tools.py">loan_tools.py</a>:</p><h4>Search for loan folders</h4><pre>from langchain_core.tools import tool<br>from box_ai_agents_toolkit import box_locate_folder_by_name<br><br>@tool(parse_docstring=True)<br>def search_loan_folder(applicant_name: str) -&gt; str:<br>    &quot;&quot;&quot;Locate a loan application folder in Box by applicant name.<br>    <br>    Args:<br>        applicant_name: Name of the loan applicant (e.g., &quot;Sarah Chen&quot;)<br>    <br>    Returns:<br>        Folder ID and path information<br>    &quot;&quot;&quot;<br>    folder = box_locate_folder_by_name(<br>        client=conf.box_client,<br>        folder_name=applicant_name,<br>        parent_folder_id=conf.BOX_DEMO_PARENT_FOLDER,<br>    )<br>    <br>    if folder:<br>        return f&quot;Found folder: {folder.name} (ID: {folder.id})&quot;<br>    return f&quot;Folder not found for applicant: {applicant_name}&quot;</pre><p>The @tool decorator converts any function into a LangChain tool. The docstring becomes the tool&#39;s description that the agent sees.</p><h4>List documents in a folder</h4><pre>from box_ai_agents_toolkit import box_folder_items_list<br><br>@tool(parse_docstring=True)<br>def list_loan_documents(folder_id: str) -&gt; str:<br>    &quot;&quot;&quot;List all documents in a loan application folder.<br>    <br>    Args:<br>        folder_id: Box folder ID containing the loan application<br>    <br>    Returns:<br>        List of files in the folder with names and IDs<br>    &quot;&quot;&quot;<br>    response = box_folder_items_list(<br>        client=conf.box_client,<br>        folder_id=folder_id,<br>        is_recursive=False<br>    )<br>    <br>    result = f&quot;Documents in folder {folder_id}:\n\n&quot;<br>    for item in response.get(&quot;folder_items&quot;, []):<br>        item_type = &quot;📁&quot; if item.get(&quot;type&quot;) == &quot;folder&quot; else &quot;📄&quot;<br>        result += f&quot;{item_type} {item.get(&#39;name&#39;)} (ID: {item.get(&#39;id&#39;)})\n&quot;<br>    <br>    return result</pre><h4>Ask Box AI questions</h4><p>This is where it gets interesting. Instead of parsing PDFs manually, we ask Box AI:</p><pre>from box_ai_agents_toolkit import box_ai_ask_file_multi<br><br>@tool(parse_docstring=True)<br>def ask_box_ai_about_loan(folder_id: str, question: str) -&gt; str:<br>    &quot;&quot;&quot;Ask Box AI a question about documents in a loan application folder.<br>    <br>    Args:<br>        folder_id: Box folder ID containing the loan application<br>        question: Question to ask about the loan application<br>    <br>    Returns:<br>        Box AI&#39;s response with information from the documents<br>    &quot;&quot;&quot;<br>    # Get all file IDs in the folder<br>    folder_response = box_folder_items_list(<br>        client=conf.box_client,<br>        folder_id=folder_id,<br>        is_recursive=False<br>    )<br>    <br>    file_ids = [<br>        item.get(&quot;id&quot;) <br>        for item in folder_response.get(&quot;folder_items&quot;, [])<br>        if item.get(&quot;type&quot;) == &quot;file&quot;<br>    ]<br>    <br>    if not file_ids:<br>        return f&quot;No files found in folder {folder_id}&quot;<br>    <br>    # Ask Box AI about the files<br>    ai_response = box_ai_ask_file_multi(<br>        client=conf.box_client,<br>        file_ids=file_ids,<br>        prompt=question<br>    )<br>    <br>    # Format the response<br>    result = f&quot;Box AI Response for: {question}\n\n&quot;<br>    if isinstance(ai_response, dict):<br>        answer = ai_response.get(&quot;AI_response&quot;, {}).get(&quot;answer&quot;, &quot;&quot;)<br>        result += f&quot;Answer: {answer}\n&quot;<br>    <br>    return result</pre><p><strong>Example queries the agent makes:</strong></p><ul><li>“What is the applicant’s monthly gross income?”</li><li>“What is the maximum DTI ratio allowed for standard approval?”</li><li>“Does the applicant have any recent repossessions?”</li></ul><p>Box AI reads the PDFs, extracts the answer, and provides citations. No PDF parsing libraries, no regex hell.</p><h4>Extract structured data</h4><p>For structured extraction (credit score, income, employment details), we use Box Extract:</p><pre>from box_ai_agents_toolkit import box_ai_extract_structured_enhanced_using_fields<br><br>@tool(parse_docstring=True)<br>def extract_structured_loan_data(folder_id: str, fields_schema: str) -&gt; str:<br>    &quot;&quot;&quot;Extract structured data from loan application documents using Box AI Extract.<br>    <br>    Args:<br>        folder_id: Box folder ID containing the loan application<br>        fields_schema: JSON string defining fields to extract<br>    <br>    Returns:<br>        Extracted structured data from the documents<br>    &quot;&quot;&quot;<br>    # Get file IDs<br>    folder_response = box_folder_items_list(<br>        client=conf.box_client,<br>        folder_id=folder_id,<br>        is_recursive=False<br>    )<br>    <br>    file_ids = [<br>        item.get(&quot;id&quot;) <br>        for item in folder_response.get(&quot;folder_items&quot;, [])<br>        if item.get(&quot;type&quot;) == &quot;file&quot;<br>    ]<br>    <br>    # Parse the fields schema<br>    fields = json.loads(fields_schema)<br>    <br>    # Extract structured data using Box AI<br>    ai_response = box_ai_extract_structured_enhanced_using_fields(<br>        client=conf.box_client,<br>        file_ids=file_ids,<br>        fields=fields<br>    )<br>    <br>    result = f&quot;Extracted Data from Folder {folder_id}:\n\n&quot;<br>    result += json.dumps(ai_response.get(&quot;AI_response&quot;, {}).get(&quot;answer&quot;, {}), indent=2)<br>    <br>    return result</pre><p>The agent defines fields like:</p><pre>[<br>  {<br>    &quot;key&quot;: &quot;credit_score&quot;,<br>    &quot;type&quot;: &quot;number&quot;,<br>    &quot;prompt&quot;: &quot;Applicant&#39;s FICO credit score&quot;<br>  },<br>  {<br>    &quot;key&quot;: &quot;monthly_income&quot;,<br>    &quot;type&quot;: &quot;float&quot;,<br>    &quot;prompt&quot;: &quot;Gross monthly income in dollars&quot;<br>  }<br>]</pre><p>Box AI extracts the values across multiple documents and returns structured JSON. No manual field mapping.</p><h4>Upload reports back to Box</h4><p>After making a decision, the orchestrator uploads reports:</p><pre>from utils.box_api_generic import local_file_upload<br><br>@tool(parse_docstring=True)<br>def upload_text_file_to_box(<br>    parent_folder_id: str,<br>    file_name: str,<br>    local_file_path: Path<br>) -&gt; str:<br>    &quot;&quot;&quot;Upload a text file to a specified Box folder.<br>    <br>    Args:<br>        parent_folder_id: Box folder ID where the file will be uploaded<br>        file_name: Name of the file to be created in Box<br>        local_file_path: Path to the local text file to upload<br>    <br>    Returns:<br>        Confirmation message with uploaded file details<br>    &quot;&quot;&quot;<br>    # Translate virtual path to real filesystem path<br>    real_file_path = conf.local_agents_memory / local_file_path.relative_to(&quot;/memories/&quot;)<br>    <br>    file_id = local_file_upload(<br>        client=conf.box_client,<br>        local_file_path=real_file_path,<br>        parent_folder_id=parent_folder_id,<br>    )<br>    <br>    return f&quot;File &#39;{file_name}&#39; uploaded successfully (File ID: {file_id})&quot;</pre><p>This closes the loop: extract from Box, process with agents, upload results back to Box.</p><h3>Running the demo</h3><p>The entry point is <a href="https://github.com/box-community/langchain-box-loan-demo/blob/main/src/demo_loan.py">demo_loan.py</a>:</p><pre>import asyncio<br>from agents.loan_orchestrator import loan_orchestrator_create<br>from utils.display_messages import stream_agent<br><br>async def test_loan_application(applicant_name: str):<br>    # Create the orchestrator<br>    agent = loan_orchestrator_create(applicant_name=applicant_name)<br>    <br>    # Process the loan application<br>    request = f&quot;Please process the auto loan application for {applicant_name}&quot;<br>    <br>    # Stream the response (real-time updates)<br>    await stream_agent(<br>        agent,<br>        {&quot;messages&quot;: [{&quot;role&quot;: &quot;user&quot;, &quot;content&quot;: request}]}<br>    )<br><br># Run it<br>asyncio.run(test_loan_application(&quot;David Martinez&quot;))</pre><p><strong>What happens:</strong></p><p><strong>Orchestrator receives request</strong>: “Process loan for David Martinez”</p><p><strong>Delegates to box-extract-agent</strong>:</p><ul><li>Searches for “David Martinez” folder</li><li>Lists documents</li><li>Extracts structured data (income, credit score, vehicle details)</li><li>Writes findings to /memories/David_Martinez/data_extraction.md</li></ul><p><strong>Delegates to policy-agent</strong>:</p><ul><li>Queries policy documents for DTI/credit thresholds</li><li>Writes findings to /memories/David_Martinez/policy.md</li></ul><p><strong>Delegates to risk-calculation-agent</strong>:</p><ul><li>Calculates DTI: (monthly_debts + proposed_payment) / monthly_income</li><li>Calculates LTV: loan_amount / vehicle_value</li><li>Identifies violations</li><li>Writes findings to /memories/David_Martinez/risk_calculation.md</li></ul><p><strong>Orchestrator synthesizes</strong>:</p><ul><li>Reviews all sub-agent reports</li><li>Applies decision framework</li><li>Writes final decision to /memories/David_Martinez/underwriting_decision.md</li></ul><p><strong>Orchestrator uploads</strong>: All reports back to David’s Box folder</p><p><strong>David Martinez’s outcome:</strong> 🚨 <strong>ESCALATION REQUIRED</strong></p><ul><li>Credit: 640 (fair)</li><li>DTI: 47% (moderate violation, &gt;43%)</li><li>LTV: 107% (minor violation, negative equity)</li><li>Decision: Requires regional director approval</li></ul><h3>Why this works</h3><p><strong>Separation of concerns</strong></p><p>Each agent has one job:</p><ul><li><strong>box-extract-agent</strong> doesn’t calculate risk</li><li><strong>policy-agent</strong> doesn’t extract data</li><li><strong>risk-calculation-agent</strong> doesn’t interpret policies</li></ul><p>This makes the system debuggable. If DTI calculation is wrong, you know exactly where to look.</p><p><strong>Persistent audit trail</strong></p><p>Every calculation, extraction, and decision is written to /memories/. For regulated industries, this is gold. You can trace back:</p><ul><li>Where did the credit score come from? → data_extraction.md</li><li>How was DTI calculated? → risk_calculation.md</li><li>What policy threshold was used? → policy.md</li></ul><p><strong>Tool isolation</strong></p><p>The orchestrator can’t accidentally call calculate() - it doesn&#39;t have access to that tool. This prevents the &quot;God agent&quot; anti-pattern where one agent tries to do everything.</p><p><strong>Box AI does the heavy lifting</strong></p><p>Instead of:</p><pre># Manual PDF parsing nightmare<br>pdf_text = extract_text_from_pdf(file_path)<br>income = parse_income_from_text(pdf_text)  # Good luck with this<br>credit_score = parse_credit_score(pdf_text)  # Hope the format doesn&#39;t change</pre><p>You get:</p><pre># Natural language query<br>answer = ask_box_ai_about_loan(folder_id, &quot;What is the applicant&#39;s monthly income?&quot;)</pre><p>Box AI handles OCR, document understanding, and context extraction. You focus on business logic.</p><h3>The demo spectrum</h3><p>The repo includes 4 test applicants representing the full decision spectrum:</p><ul><li><strong>Sarah Chen</strong><br>Credit: 750 <br>DTI: 12.1%<br>✅ AUTO-APPROVE</li><li><strong>Marcus Johnson</strong><br>Credit: $680<br>DTI: 42.1%<br>⚠️ HUMAN REVIEW</li><li><strong>David Martinez</strong><br>Credit: $640<br>DTI: 47.0%<br>🚨 ESCALATION REQUIRED</li><li><strong>Jennifer Lopez</strong><br>Credit: 575<br>DTI: 54.7%<br>🚫 AUTO-DENY</li></ul><p>Run all four to see how the agent handles different risk levels:</p><pre>asyncio.run(test_loan_application(&quot;Sarah Chen&quot;))    # Clean approval<br>asyncio.run(test_loan_application(&quot;Jennifer Lopez&quot;)) # Clear denial</pre><h3>Key takeaways</h3><p><strong>Deep Agents gives you:</strong></p><ul><li><strong>Orchestrator pattern</strong> — coordinate workflows without chaos</li><li><strong>Sub-agent isolation</strong> — single responsibility, limited tool access</li><li><strong>Persistent memory</strong> — audit trails for compliance</li><li><strong>Type-safe tools</strong> — LangChain tool system with validation</li></ul><p><strong>Box AI gives you:</strong></p><ul><li><strong>Natural language document queries</strong> — no PDF parsing</li><li><strong>Structured data extraction</strong> — define fields, get JSON</li><li><strong>150+ toolkit functions</strong> — file ops, search, collaboration, enterprise features</li><li><strong>Enterprise-ready</strong> — security, compliance, audit logs</li></ul><p><strong>Together:</strong></p><ul><li>Build multi-agent systems that don’t collapse under their own complexity</li><li>Process documents intelligently without reinventing OCR</li><li>Create audit trails for regulated workflows</li><li>Focus on business logic, not infrastructure</li></ul><h3>Try it yourself</h3><p><strong>Repo:</strong> <a href="https://github.com/box-community/langchain-box-loan-demo">github.com/box-community/langchain-box-loan-demo</a></p><p><strong>Requirements:</strong></p><ul><li>Python 3.13+</li><li>Box account (free tier works)</li><li>Anthropic API key</li></ul><p><strong>Questions?</strong> Open an issue or reach out. I’m a developer advocate at Box, not a salesperson — I want to see what you build with this.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=42e6afc62dbb" width="1" height="1" alt=""><hr><p><a href="https://medium.com/box-developer-blog/building-systems-with-langchain-deep-agents-and-box-42e6afc62dbb">Building systems with Langchain deep agents and Box</a> was originally published in <a href="https://medium.com/box-developer-blog">Box Developer Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Year in review: How Box Developer Relations helped you build with AI in 2025]]></title>
            <link>https://medium.com/box-developer-blog/year-in-review-how-box-developer-relations-helped-you-build-with-ai-in-2025-45def7452bc7?source=rss----a995c24848a3---4</link>
            <guid isPermaLink="false">https://medium.com/p/45def7452bc7</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[box]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Rui Barbosa]]></dc:creator>
            <pubDate>Thu, 08 Jan 2026 12:02:46 GMT</pubDate>
            <atom:updated>2026-01-08T12:02:45.476Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/768/1*FPgQoRoIWZEtO2kWoSmGJQ.avif" /></figure><p>2025 was the year developers shifted from experimenting with AI to building mission-critical workflows with it.</p><p>During this time, the Box Developer Relations team focused on enabling this shift across various fronts — including our technical content, events, hackathons, amazing partnerships, improvements to our developer documentation portal, and more. To continue our team’s tradition, we’d like to recap and reflect on how we served our developer community in the past twelve months.</p><h3>50+ transformative publications released</h3><p>This past year, the Box Developer Relations team <a href="https://medium.com/box-developer-blog/all">published</a> an extraordinary 57 pieces of content, cementing 2025 as the year of Box AI.</p><p>Our content strategy reflected the transformative wave sweeping through enterprise development, with over 20 articles dedicated to AI integrations and innovative use cases. From deep technical guides on <a href="https://blog.box.com/box-ai-api-deep-dive-coding-power-context">Box AI API</a> capabilities to groundbreaking integrations with popular AI frameworks like <a href="https://medium.com/box-developer-blog/writing-a-box-agent-with-langchain-easier-than-you-think-00b53013c3e2">LangChain</a>, <a href="https://medium.com/box-developer-blog/building-ai-powered-workflows-with-langgraph-and-box-api-edc5ec18fa2f">LangGraph</a>, <a href="https://medium.com/box-developer-blog/using-contextual-retrieval-with-box-and-pinecone-fe4156e08082">Pinecone</a>, and <a href="https://medium.com/box-developer-blog/building-an-enterprise-ai-agent-how-to-combine-box-mongodb-atlas-openai-and-langchain-for-e1625e9ecd67">OpenAI</a>, we’ve helped developers unlock new possibilities for intelligent document workflows.</p><p>We also embraced the emerging <a href="https://medium.com/box-developer-blog/securing-mcp-servers-99db4a5caa73">Model Context Protocol (MCP)</a> ecosystem, publishing multiple guides on building AI agents that seamlessly integrate Box’s Intelligent Content Management capabilities with cutting-edge AI tools. Whether developers were building multi-agent workflows, extracting structured data from contracts, or implementing contextual retrieval for RAG applications, our content provided the technical foundation they needed to succeed.</p><p>Beyond AI, we maintained our commitment to making <a href="https://developer.box.com/guides">Box Platform</a> more accessible and powerful for developers at every level. We published comprehensive guides on Box’s newest features including the Document Generation API, Box Hubs API, and enhanced UI Elements customization.</p><p>Our team demystified complex topics like service accounts, SDK migrations, and metadata extraction workflows while providing practical workshops on real-world scenarios from property lease management to insurance claims automation. Each article was crafted with the developer experience in mind — complete with code samples, step-by-step tutorials, and best practices drawn from real implementation scenarios.</p><p>As we look back at these publications, we’re proud to have served as a bridge between Box’s powerful platform capabilities and the innovative developers building the future of enterprise content management.</p><h3>Events explored the future of AI</h3><p>2025 was a transformative year for Box Developer Relations, marked by an ambitious calendar of events that brought together developers, partners, and industry leaders to explore the future of enterprise AI and Intelligent Content Management.</p><p>From intimate technical workshops and in-person Developer Days, to major industry conferences, our event strategy focused on three key pillars: hands-on technical education, strategic partner collaboration, and fostering a vibrant global developer community across multiple continents.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kVjT0CzfFMY-zLxFbXdN8g.avif" /></figure><p>The year’s flagship event, <a href="https://medium.com/box-developer-blog/boxworks-2025-dev-zone-recap-4a0bf04b5474">BoxWorks</a> in San Francisco (September 11–12), exemplified our commitment to developer success through its expanded two-day format. The Dev Zone featured strategic partner sessions from IBM, AWS, Pinecone, Autonomy, SoftServe, and Mistral, demonstrating real-world implementations of Box’s AI capabilities at enterprise scale.</p><p>Day two’s Master Classes transformed theoretical knowledge into practical skills, with developers working directly alongside Box engineers to build custom workflows with the Box MCP server, explore advanced Box AI API use cases, and create multi-agentic applications. Participants left with working prototypes and implementation roadmaps, embodying our philosophy of learning through building.</p><p>Beyond BoxWorks, we maintained an active global presence throughout the year. We launched our first-ever BoxWorks London Developer Summit in June, establishing Box Community as the UK’s first officially recognized AI community on the DevITJobs platform. Our virtual Content + AI Summit in May featured collaborative technical sessions with guest experts — like OpenAI’s Dmitry Pimenov, Anthropic’s Sam Flamini, and Salesforce’s Karan Sethi, who demonstrated Box’s deep integration with leading AI platforms.</p><p>We engaged developers at major industry conferences including Google Next in Las Vegas (April), LangChain’s Interrupt Conference in San Francisco (May), served as Platinum sponsor of Salesforce London’s Calling (June), and joined Zapier’s ZapConnect (July).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VcUMAbBYmiELE5BotyPM8g.avif" /></figure><p>We closed the year strong with Scott Hurrey’s technical session at AI Dev Day in New York City (November) on scaling enterprise AI with MCP and agent-to-agent protocols, and hosted content.to_context(), our first full-day AI agent hackathon at AWS’s Palo Alto office (November). Additionally, partnered with DeepLearning.AI to create a short course on building AI apps with MCP servers, extending our educational reach to developers worldwide.</p><p>This comprehensive event portfolio reinforced Box’s position as the Intelligent Content Management platform for the AI era, while strengthening our global developer community through meaningful technical engagement, strategic partnerships, and a relentless commitment to practical, hands-on learning that empowers developers to immediately apply their knowledge.</p><h3>Videos captured the pulse of AI innovation</h3><p>This year marked an extraordinary expansion of our video content strategy, with the Box Developer Relations team producing an impressive collection that showcased the rapidly evolving landscape of AI-powered development with Box.</p><p>From exploring cutting-edge AI models like GPT-5, Claude Sonnet 4.5, Gemini 3, and Grok 3 through our “Model Behavior” series, to demonstrating practical implementations with GitHub Copilot, OpenAI’s Agent Builder and Responses API, and Google’s Agent Development Kit (ADK), these videos captured the pulse of AI innovation as it happened. Our “AI in Action” series provided real-world demonstrations of how developers can leverage Box’s AI capabilities in production environments, while our technical deep-dives explored integrations with emerging technologies like Claude’s Model Context Protocol (MCP) and Mistral’s Le Chat.</p><p>The crown jewel of this year’s video efforts was our comprehensive exploration of agentic workflows — a collection of hands-on tutorials that demonstrated how developers can build sophisticated AI agents using Box as their content layer. Videos covering LangChain, LangGraph, Pydantic, and OpenAI’s new Agents SDK showed the community how to construct intelligent systems that can process insurance claims, extract metadata from documents, generate code, and orchestrate complex multi-step workflows.</p><p>We also expanded our focus on practical developer tooling, with tutorials on setting up the Box MCP server with Cursor, building document generation apps with Claude Code, and leveraging Snowflake’s Openflow connector for automated metadata extraction. These 25 videos represent not just a documentation of the year’s technical innovations, but a commitment to empowering our developer community with the knowledge and tools they need to build the next generation of content-intelligent applications.</p><h3>Hear from DevRel team members</h3><p>And now, hear directly from our team members sharing their highlights and proud moments from this year.</p><h3>Scott Hurrey, Director Developer Relations</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tnyU5rpfIsKHXnUyjNZ1mg.avif" /></figure><p>2025 was a big year for Box and AI. Our team was incredibly active in building demos, connectors, and content. To see value from AI, context is key, and Box has more than an exabyte of unstructured data and the tools you need to turn that content into context.</p><p>I’m especially proud of our team for adjusting to the new normal, adopting AI as a core part of what we do, even as we strive to demonstrate AI capabilities with Box in the form of videos, blogs, and workshops. We also made several strategic pivots in how we work to better the output and focus on what’s important.</p><p>We also had a great year for events. The highlights for me were our AI developer-focused BoxWorks Masterclass with standing room only attendance, the content.to_context() hackathon with our friends at AWS and SoftServe, and sponsorship at both LangChain Interrupt and AI Dev NYC. I can’t wait to build on this in 2026!</p><p>We saw a valued team member, Alex Novotny, move on to a new opportunity to grow his talents. I’d like to share a warm congratulations to Alex. I know he will knock it out of the park.</p><p>We also welcomed Andrew Wong to the team, a fantastic advocate with killer video skills. Andrew stepped in on day one (literally) to take the reins on our video practice and has become an integral part of our content engine.</p><p>Olga has done a fantastic job stepping up and out, releasing a Box connector for LangChainJS. If you have read <a href="https://medium.com/@stefaniuk.olga">Olga’s content</a>, you know she is an amazing front-end developer. LangChainJS was her chance to show off her back-end skills. She also continued the amazing work she does in her community, as well as in the Box community, which culminated in a nomination for the WomenTech Network Leader of the Year Award.</p><p>And of course Rui did what Rui does: Build a ton of code to help developers pull Box content into AI applications easily, allowing them to focus on the problem they are trying to solve. And of course all of this came with engaging content to help you use and understand these tools.</p><p>And I’d be remiss if I didn’t mention our fantastic writers. Justi, Ian, and Ana have done tremendous work documenting all of our releases so developers can easily understand and get started with new and existing APIs, and Rene and Charles teamed up with them to make sure every product feature and enhancement is documented on time to help all Box users make the most of the product. Łukasz has done an amazing job managing the team and keeping our users engaged and informed. We couldn’t do this work without all of our team members.</p><h3>Andrew Wong, Senior Developer Advocate</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TvXYwG02pzcL6azYrulAQQ.avif" /></figure><p>Since joining the Box Developer Relations team last summer, 2025 has been the year that let me fully combine the things I love: teaching, building, and experimenting. I focused much of my energy on creating technical video content that walked developers through everything from new AI models (GPT-5+, Claude Sonnet 4.5, Gemini 3 Pro) to hands-on demos with tools like MCP connectors, OpenAI Agent Builder, Google ADK, Claude Enterprise Search, and ChatGPT Company Knowledge.</p><p>I also loved getting to speak at Zapier’s ZapConnect conference, another chance to tap back into my teaching side and connect with builders in a different context. And co-hosting the Box + AWS Hackathon (my first in years!) reminded me how energizing and fun that kind of creative, high-velocity environment can be.</p><p>I’m deeply grateful for the support, collaboration, and humor across our DevRel team, and for the developers who engaged with the demos, asked thoughtful questions, and pushed the ideas further. Looking ahead, I’m excited to keep building things that help people learn, experiment, and ship even faster in 2026.</p><h3>Rui Barbosa, Senior Developer Advocate</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Tb5O7pXTU_pytCPDi_EaPg.avif" /></figure><p>This year marked a transformative period in my work with the Box Developer Relations team, driven by an intense focus on AI integration and developer tooling.</p><p>My primary achievement was authoring the <a href="https://blog.box.com/introducing-new-mcp-server-tools-collaboration">Box MCP</a> (Model Context Protocol) server, which became a cornerstone project that generated significant community engagement and adoption. This foundational work opened new possibilities for developers to integrate Box seamlessly with AI applications, sparking a wave of activity across the ecosystem.</p><p>Throughout the year, I <a href="https://medium.com/@barbosa-rmv">published over 20 technical articles</a>, each accompanied by practical code samples demonstrating Box features in action. My work spanned the full spectrum of modern AI development, from building multi-agent workflows with OpenAI and LangGraph to creating enterprise-grade AI agents combining Box with MongoDB Atlas and LangChain.</p><p>I explored cutting-edge integrations with platforms like n8n, <a href="https://blog.box.com/extracting-structured-data-from-contracts-using-box-ai-airbyte-and-motherduck">Airbyte</a>, and MotherDuck, while also diving deep into specialized use cases such as OCR-powered metadata extraction, insurance claims automation with DocGen, and structured data extraction from contracts.</p><p>A recurring theme in my articles was making complex AI workflows accessible — whether teaching Claude to use the Box API, demonstrating LangChain integrations, or showcasing Box AI’s capabilities for document analysis and generation.</p><p>Beyond technical tutorials, I also contributed to community enablement through workshops on property lease management and document automation, ensuring developers had both the knowledge and hands-on experience to leverage Box’s powerful API and AI features effectively.</p><h3>Olga Stefaniuk, Developer Advocate</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LwpLpE-aFXxTAwHbROje1w.avif" /></figure><p>Serving the Box developer community this year has led me to exploring a lot of new areas. Not only have I successfully led our first developer track at BoxWorks London, but also I explored new technical domains including the LangChain ecosystem by delivering a <a href="https://medium.com/box-developer-blog/create-rag-powered-apps-with-box-loader-for-langchain-js-d7c45a13957b">JavaScript loader for Box content</a>.</p><p>It’s been an intense year full of collaboration with multiple teams to ensure we deliver outstanding developer experiences. Thanks to a joint effort of several teams, we delivered the new <a href="https://blog.box.com/developer">developer blog</a> and an updated UI of the <a href="https://developer.box.com/">developer portal</a> enhanced with an AI-first approach.</p><p>I also had a chance to tighten collaboration with our Box Platform Tools team to launch <a href="https://medium.com/box-developer-blog/navigating-box-sdk-consolidation-which-version-to-use-and-how-to-migrate-c24c27e37982">the v10 of Box SDKs</a>. I’m lucky to create our developer newsletter that is sent monthly, so you can stay up to date with the latest product updates, releases, tutorials, and videos our team creates throughout the whole year.</p><h3>Box Developer Community</h3><p>Our team is extremely grateful for all interactions and time spent in person and online with developers driving solutions based on Box Platform. You’ve showed up at our events, asked questions, interacted with our content, and provided valuable feedback that resulted in many product improvements and shaped our solutions. As always, we stay open to your feedback on how we can improve in the upcoming year.</p><p>We’d like to also thank our partners for an opportunity for collaboration, pushing boundaries and building impressive solutions. We look forward to next year that will lead to multiplying the latest trends and exploring new patterns of working with Box Intelligent Content Cloud. We’ll continue to deliver outstanding developer-focused content, improve developer experience and help you to create integrations at a faster pace.</p><p>Thank you for being a part of this journey and we wish you all the best in the upcoming new year.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=45def7452bc7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/box-developer-blog/year-in-review-how-box-developer-relations-helped-you-build-with-ai-in-2025-45def7452bc7">Year in review: How Box Developer Relations helped you build with AI in 2025</a> was originally published in <a href="https://medium.com/box-developer-blog">Box Developer Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Box launches new AI-First developer documentation site]]></title>
            <link>https://medium.com/box-developer-blog/box-launches-new-ai-first-developer-documentation-site-c4c368f2b675?source=rss----a995c24848a3---4</link>
            <guid isPermaLink="false">https://medium.com/p/c4c368f2b675</guid>
            <category><![CDATA[ai-chatbot]]></category>
            <category><![CDATA[content-strategy]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[documentation]]></category>
            <category><![CDATA[mcps]]></category>
            <dc:creator><![CDATA[Olga Stefaniuk]]></dc:creator>
            <pubDate>Thu, 18 Dec 2025 17:02:37 GMT</pubDate>
            <atom:updated>2025-12-18T17:02:36.137Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZFVH_QqGwDe07Cv2t4BkVQ.png" /></figure><p>Content and context have become more crucial than ever as developers adopt AI-first coding techniques and leverage LLMs for searching for information. To stay at the forefront of that change, Box is launching a new Box developer documentation site that includes:</p><ul><li><strong>AI-powered chat and advanced search</strong> to answer any questions related to Box Platform</li><li><strong>Box developer documentation MCP server,</strong> which can be invoked directly from your IDE to connect to Box developer documentation</li><li><strong>An interactive API playground, </strong>and much more</li></ul><p>Here’s a quick tour of the new site and its features.</p><p>⚠️ <em>This is a beta version of the new Box developer documentation experience.</em></p><h4>What’s new</h4><p>The whole new developer portal is built on<a href="https://www.mintlify.com/"> Mintlify</a>, an intelligent documentation platform trusted by companies at the forefront of the AI revolution. That’s why the patterns you’ll notice in our developer documentation site might seem familiar, resembling those of Claude Cursor, Vercel, or Perplexity documentation sites, to name a few.</p><p>The first and most noticeable changes you might enjoy are <strong>dark mode, a simplified home page, and an enhanced main navigation</strong>. You can also quickly access developer guides from the left-hand side panel. This gives you a clear, responsive book structure with global and single-page tables of contents, all designed for enhanced developer productivity.</p><h3>AI-powered features</h3><h4>AI assistant</h4><p>To start a conversation with our AI assistant, submit your question to the input at the bottom on the page. A right-hand side panel will open with a generated answer. From now on, you can ask questions about authentication flows, troubleshoot error codes, or get code examples in your preferred language. The chatbot delivers generative answers powered by AI-enhanced search that aggregates results from across all Box sites, giving you the most relevant information without time-consuming searching.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/768/1*BZRVnq23dmg6jzS3tet_Ag.gif" /></figure><h4>AI hints for code snippet</h4><p>Another form of interacting with the AI assistant is the <em>Ask AI</em> feature within the code snippet component available on the API reference page for each endpoint. Hit the button, and you’ll get a detailed breakdown of the code. It’s definitely a great feature for those starting out with our API.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/489/1*K60MxP121NhEwTupZz_Lzg.png" /></figure><h4>AI-powered search</h4><p>Additionally, the search functionality runs on RAG powered by Claude Opus 4.5 and includes a knowledge base of not only the developer documentation, but also Box product documentation, our Box Community Forum, and other useful resources that help you get to know the Box ecosystem holistically.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/729/1*PNSXml2Mo_Urgxjs8MNqrw.png" /></figure><h3>Interact with Box Developer Docs directly from IDE</h3><p>Our new contextual menu allows you to perform a set of actions such as asking questions related to a specific page in an AI agent of your choice, including ChatGPT, Claude, or Preplexity.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/732/1*ImbDNksmJM5V6krRXsqN6w.png" /></figure><p>Moreover, there is the new <strong>Box developer documentation MCP server</strong> that you can use to interact with Box technical content without even leaving your favorite IDE. Your AI assistant can now pull accurate, up-to-date information to help you write custom apps and integrations, understand authentication patterns, or troubleshoot issues .</p><p>Simply click <em>Connect to Cursor</em> to initiate the installation process or copy the link to the MCP server and set up manually. At this stage, you can leverage the tool called <em>SearchBoxDeveloperDocumentation</em>. In further iterations, this MCP server will be also enhanced with additional context of the whole Box OpenAPI specification and will be able to generate even more accurate responses.</p><h4>Try out endpoints within the API reference page</h4><p>Our new interactive API testing experience lets you experiment with Box APIs directly within the documentation. Simply select an endpoint, click the <em>Try it</em> button, configure your parameters within the modal, and execute a real API call. For authorization, you’ll need a developer token from Box Developer Console within the app settings interface.</p><p>The experience on the Box developer documentation will display the response status code and returned values directly from Box API.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fKe2dSCfhI53D1MA01uM_Q.gif" /></figure><h4>Get started today</h4><p>We hope you’ll get the most out of our new developer portal. Stay tuned for the next batch of updates with new quick-start guides based on use cases, Box SDK code snippets, and more.</p><p>Try it out for yourself: Visit<a href="https://developer.box.com/"> developer.box.com</a> and discover how our AI-first developer documentation can accelerate the creation process of your Box integrations. We’d love to hear what you think about the new experience and how we can improve it further. Post your feedback on the<a href="https://community.box.com/box-platform-5"> developer forum</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c4c368f2b675" width="1" height="1" alt=""><hr><p><a href="https://medium.com/box-developer-blog/box-launches-new-ai-first-developer-documentation-site-c4c368f2b675">Box launches new AI-First developer documentation site</a> was originally published in <a href="https://medium.com/box-developer-blog">Box Developer Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Using Box MCP server with Google ADK agent]]></title>
            <link>https://medium.com/box-developer-blog/using-box-mcp-server-with-google-adk-agent-c2431f60c088?source=rss----a995c24848a3---4</link>
            <guid isPermaLink="false">https://medium.com/p/c2431f60c088</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[box]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Rui Barbosa]]></dc:creator>
            <pubDate>Thu, 11 Dec 2025 12:02:23 GMT</pubDate>
            <atom:updated>2025-12-11T12:02:22.145Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hAd-p7whs6Po0BD6PtSUyg.png" /></figure><p>When Google’s Agent Development Kit meets Box’s Intelligent Content Management platform, something remarkable happens: Sophisticated AI agents that can analyze contracts, process documents, and orchestrate complex business workflows become trivially simple to build.</p><p>What typically requires months of API integration work and custom tooling can now be accomplished with eight lines of code, thanks to the model context protocol (MCP) and our newly enhanced <a href="https://www.box.com/mcp-server">Box MCP server</a>.</p><h4>The eight lines of code agent</h4><p>What if I told you that connecting Google’s Agent Development Kit to your Box instance takes exactly eight lines of code? Here’s the proof:</p><pre>root_agent = LlmAgent(<br>    model=&quot;gemini-2.0-flash&quot;,<br>    name=&quot;ADK_Agent_Box_MCP&quot;,<br>    instruction=&quot;You are a helpful agent with access to the Box MCP server, and can help users access their Box instance&quot;,<br>    tools=[<br>        MCPToolset(<br>            connection_params=SseConnectionParams(<br>                url=&quot;http://localhost:8001/sse&quot;,<br>            ),<br>        ),<br>    ],<br>)</pre><p>Yes, it’s really this simple — for development and prototyping. Let me show you what this unlocks and when you’d want to use it.</p><h3>What you get out of the box with Box</h3><p>The Box MCP (model context protocol) server gives your AI agents immediate access to enterprise-grade content operations:</p><ul><li>Search for files</li><li>Manage folders</li><li>Read files</li><li>Upload files</li><li>Download files</li><li>Use Box AI to ask questions about files</li><li>Use Box Doc Gen to generate documents from templates</li><li>Manage metadata templates and instances</li></ul><p>Google’s Agent Development Kit handles the orchestration, giving you sophisticated agent workflows with conversation memory, tool coordination, and <a href="https://blog.box.com/when-problems-get-complex-ai-reasoning-models-shine">multi-step reasoning</a>.</p><p>The magic happens through <a href="https://blog.box.com/securing-your-mcp-servers">Box MCP</a>, a standardized protocol that lets AI frameworks communicate with external tools without custom integrations. Instead of writing hundreds of lines of Box API wrapper code, you get a single MCPToolset that exposes all Box capabilities to your agent.</p><p>We’ve recently enhanced our MCP server with SSE (Server-Sent Events) transport support, moving beyond the original STDIO-only approach. This means better error handling, easier debugging, and more flexible deployment options. We’ve also added new tools for advanced metadata operations and document generation workflows.</p><h3>Demo: Insurance claim preliminary report</h3><p>Let me walk you through a realistic workflow that showcases the power of this integration.</p><p><strong>Scenario</strong>: The insurance claim adjusters have folders with insurance policy and claims documents. You want to extract data from these documents in a very specific format defined in a Box metadata template, and create a preliminary report.</p><p><strong>The interaction</strong>:</p><pre>locate my insurance folder and ask Box AI to give you the <br>context of those files</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*P6QzL7etBwXUpIoTFLNUsg.png" /></figure><pre>ask Box AI to extract key data from the policy document using <br>the Acme policy metadata template</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_7TQCcYfxanvV_QNFqjdsQ.png" /></figure><pre>do the same for the claim using the acme claim template</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*G4daQnWfSC7c7Hl7V4OwNw.png" /></figure><pre>ask Box AI to analyze the photos and give you a detailed description <br>of the damage, including possible hidden damage to components</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2esEemUwyHa8uqGYLljg3Q.png" /></figure><pre>with this information, create a preliminary claim report using markdown <br>formatting, and upload it to the same folder</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iElfDOZY3KDMm4PLSNmRJA.png" /></figure><p>And here is the uploaded report:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UjBffyX6zsKy_S9WuUo1aQ.png" /></figure><p><strong>What’s happening behind the scenes</strong>:</p><ul><li>Box folder search and file listing</li><li>Box AI document analysis calls</li><li>Custom metadata extraction and tagging</li><li>Document generation</li><li>Automated folder organization and file management</li></ul><p><strong>The Results</strong>: Within minutes, you have a preliminary report about the insurance claim. This helps the claim adjuster to quickly gather context on a claim and decide where to start.</p><h3>Beyond development: The production path</h3><p>While this DevRel edition gets you building quickly, production deployments require additional considerations.</p><p><strong>Authentication and security</strong>: Production systems need proper MCP client-server authentication, user session management, secure credential handling, and audit logging capabilities.</p><p><strong>Multi-tenancy</strong>: Supporting multiple users requires per-user Box authentication, workspace isolation, resource access controls, and usage monitoring.</p><p><strong>Scale and reliability</strong>: Production deployments need horizontal scaling capabilities, error recovery and retry logic, connection pooling and rate limiting, and comprehensive monitoring and alerting.</p><p><strong>When to consider alternatives</strong>: If you need immediate multi-user support, have complex enterprise security requirements, require guaranteed SLAs and support, or need extensive customization beyond MCP capabilities, you might want to build your own, contextualized MCP server, or check out the capabilities of our <a href="https://developer.box.com/guides/box-mcp/remote/">official MCP server</a>.</p><h3>The real value proposition</h3><p>This integration represents something bigger than just another API wrapper. It’s about bridging the gap between AI capabilities and enterprise reality.</p><p>Most AI agents live in isolation, working with simple APIs and toy examples. Box MCP server + Google ADK changes that equation. Suddenly, your agents can work with real enterprise content, leverage professional-grade AI analysis, and implement sophisticated business workflows.</p><p>The eight-line setup isn’t just about simplicity. It’s about removing the months of integration work that typically stand between a great AI idea and a working prototype. For developers exploring AI + enterprise content, for teams validating concepts with stakeholders, and for anyone who wants to understand what becomes possible when AI meets enterprise infrastructure, this is your fastest path forward.</p><p>The dev edition limitations are real, but they’re also temporary. By starting here, you can validate your concepts, understand the possibilities, and build the business case for more robust solutions.</p><p>Ready to give your AI agents enterprise content superpowers? The setup takes fiveminutes. The possibilities are endless.</p><p>The sample code for this article is available on our <a href="https://github.com/box-community/google-adk-box-mcp-agent">GitHub repository</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c2431f60c088" width="1" height="1" alt=""><hr><p><a href="https://medium.com/box-developer-blog/using-box-mcp-server-with-google-adk-agent-c2431f60c088">Using Box MCP server with Google ADK agent</a> was originally published in <a href="https://medium.com/box-developer-blog">Box Developer Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Box Community MCP tools - Finally proper folder management!]]></title>
            <link>https://medium.com/box-developer-blog/box-community-mcp-tools-finally-proper-folder-management-7ce15b07cc1d?source=rss----a995c24848a3---4</link>
            <guid isPermaLink="false">https://medium.com/p/7ce15b07cc1d</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[mcp-server]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[box]]></category>
            <dc:creator><![CDATA[Rui Barbosa]]></dc:creator>
            <pubDate>Thu, 04 Dec 2025 12:02:15 GMT</pubDate>
            <atom:updated>2025-12-04T12:03:12.215Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0XDFljiwMpjPdodqMJ-ajA.png" /></figure><p>After far too long, we’re shipping a comprehensive set of tools for folder manipulation in Box. If you’ve been cobbling together workarounds or manually clicking through the UI, this update is for you.</p><h3>What you can actually do now</h3><h4>The basics (that should have always been there)</h4><p>Create, rename, move, copy, and delete folders programmatically. Yes, really. You can now build folder structures on the fly, reorganize content at scale, and tear down what you don’t need anymore. The delete operation even supports recursive deletion when you need to nuke an entire tree. Be careful!</p><h4>Information and discovery</h4><p>Pull detailed info about any folder or list its contents. The list operation goes beyond surface-level too: turn on <em>recursive traversal</em> and you’ll get everything nested underneath, however deep it goes. Perfect for auditing, backup workflows, or finding that one file buried three levels down.</p><h4>Organization</h4><p>Add descriptions to folders so people actually know what they’re looking at. Tag folders for categorization and search. Query those tags when you need them. It’s basic organizational hygiene that’s now scriptable.</p><h4>User experience touches</h4><p>Mark folders as favorites (or remove them from favorites). It’s a small thing, but when you’re building tools for actual humans, these details matter.</p><h4>Collaboration and access controls</h4><p>Configure who can invite collaborators to a folder and whether non-owners can see the full collaborator list. Lock down collaboration to your enterprise only if needed. Set upload email addresses so external folks can contribute without full access. Control sync behavior for folders.</p><h3>Combining tools: real scenarios</h3><p><strong>Project template setup</strong>: Create a new project folder, set its description, configure collaboration settings to enterprise-only, then copy your standard subfolder structure into it. Add relevant tags for discoverability and mark it as a favorite for the team lead.</p><p><strong>Content migration</strong>: List all items in a source folder recursively, create the destination structure, copy folders over with new names, verify the migration by comparing recursive listings, then clean up by removing old folders.</p><p><strong>Bulk organization</strong>: Query folders by listing contents across multiple parent directories, add consistent tags based on content type or date, update descriptions programmatically, and reorganize by moving folders into a new taxonomy.</p><p><strong>Access management audit</strong>: Retrieve folder info to check collaboration settings, list all tags to verify classification, query favorites to understand what teams are actively using, then bulk-update collaboration policies where needed.</p><p><strong>Automated cleanup</strong>: Recursively list folder contents, identify stale directories based on your criteria, remove from favorites if present, strip out tags, then delete with recursive flag enabled.</p><h3>The step-by-step demo</h3><p>Let’s start by simple creating a folder:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xiT3ZUzoUb2GhhQ2FJCm5A.png" /><figcaption>Claude creating and renaming a folder</figcaption></figure><p>Of course I had to get that wrong and needed to rename the folder.</p><p>Now let’s add a description and some tags:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gXc6eudFKbjoicHReiavNw.png" /><figcaption>Claude added description and tags</figcaption></figure><p>I also want to see this folder in my favorites:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tyeEZwaoEnWf-KADzAAujw.png" /><figcaption>Claude added the folder to my favorites</figcaption></figure><p>This is what the folder looks like now:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0IxbZIRGN3kKZ8b5Ptu1hw.png" /><figcaption>The created folder in the Box app</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*e_vodtqwUjeYkOne31EBkQ.png" /><figcaption>Box app displaying the folder tags</figcaption></figure><p>Now let’s create a bit of a structure:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YblwBffR_FriJD0O5erLKg.png" /><figcaption>Claude created two folders</figcaption></figure><p>And I messed it up again. Let’s move the contracts folder into the legal folder:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IR22mQWyxmOhsIf9MqGEhQ.png" /><figcaption>Claude moved the Contracts folder</figcaption></figure><p>Now a need the exact same structure to store older documents, like an archive:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LEXw9XV10JsggaBk0nDzig.png" /><figcaption>Claude copied and renamed an entire folder structure</figcaption></figure><p>Let’s check what we can see now:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YJ_5UDRT0pPM6yE4jiCMlw.png" /><figcaption>Claude listing the demo folder recursively</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qFgiSRuqvbL3Fb_zZ8hJ9w.png" /><figcaption>Demo folder in the box app</figcaption></figure><p>Now let’s clean up. Although Box does have a trash, where files and folder can be recovered, deleting folders can be disruptive to your organization:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bxy7_eRWOPS53crrhkp0Kg.png" /><figcaption>Claude deleted the folder recursively</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*58jzEUAzPWhymig_lkKB8A.png" /><figcaption>Box app can’t find the folder anymore</figcaption></figure><p>That’s it. No revolutionary breakthrough here, just solid tools that let you manage folders without fighting the platform. They work the way you’d expect them to work. Ship your automations, build your workflows, and stop clicking through web UIs.</p><p>Available now in the <a href="https://github.com/box-community/mcp-server-box">Box Community MCP server</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7ce15b07cc1d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/box-developer-blog/box-community-mcp-tools-finally-proper-folder-management-7ce15b07cc1d">Box Community MCP tools - Finally proper folder management!</a> was originally published in <a href="https://medium.com/box-developer-blog">Box Developer Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Create RAG-powered apps with Box loader for LangChain.js]]></title>
            <link>https://medium.com/box-developer-blog/create-rag-powered-apps-with-box-loader-for-langchain-js-d7c45a13957b?source=rss----a995c24848a3---4</link>
            <guid isPermaLink="false">https://medium.com/p/d7c45a13957b</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[retrieval-augmented-gen]]></category>
            <category><![CDATA[generative-ai-tools]]></category>
            <category><![CDATA[langchain]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Olga Stefaniuk]]></dc:creator>
            <pubDate>Fri, 21 Nov 2025 10:12:48 GMT</pubDate>
            <atom:updated>2025-11-21T10:12:46.871Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1HpYfYwvfPjHArB318ZDsw.avif" /></figure><p>I’m excited to announce the launch of langchainjs-box, a new document loader that brings the power of Box’s content management platform directly into your <a href="https://js.langchain.com/docs/introduction/">LangChain.js</a> applications. This package makes it seamless to integrate your Box files and folders for building RAG applications.</p><h4>Powered by Box Markdown representations</h4><p>One of the most exciting features of this loader is its built-in support for Box’s new <a href="https://medium.com/box-developer-blog/supercharge-your-ai-applications-with-boxs-new-markdown-representation-4e5842c82d78">Markdown representations</a>. Box recently introduced the ability to convert complex file formats into clean, structured Markdown — perfect for LLM-powered applications.</p><p>Our <strong>langchainjs-box</strong> loader automatically leverages Markdown representations for:</p><ul><li><strong>Microsoft Office</strong>: .docx, .pptx, .xls, .xlsx, .xlsm.</li><li><strong>Google Workspace</strong>: .gdoc, .gslide, .gslides, .gsheet.</li><li><strong>PDFs</strong>: .pdf.</li></ul><p>This means your LangChain.js applications get clean, well-structured content that’s optimized for embedding and retrieval. For other text-based files, the loader seamlessly falls back to Box text representations.</p><p><a href="https://medium.com/box-developer-blog/supercharge-your-ai-applications-with-boxs-new-markdown-representation-4e5842c82d78">Supercharge your AI applications with Box’s new Markdown representation</a></p><h4>Getting Started</h4><p>Before you start building, there are some prerequisites. Ensure you have:</p><ol><li>Node.js version 20 or higher</li><li>langchain/core package: ≥0.3.78 &lt;1.0.0</li><li>A Box account (sign up for a <a href="https://account.box.com/signup/n/developer">free developer account</a> )</li><li>A Box app created in the Box <a href="https://app.box.com/developers/console">Developer Console</a>:</li></ol><ul><li>langchainjs-box<strong> </strong>loader supports all available authentication methods</li><li>Server authentication applications using <a href="https://developer.box.com/guides/authentication/jwt/">JWT</a> or <a href="https://developer.box.com/guides/authentication/client-credentials/">Client Credentials Grant</a> must be authorized by a Box Admin before use. Check more details in this <a href="https://developer.box.com/guides/authorization/platform-app-approval/">developer guide</a>.</li></ul><p>Installing the loader is as simple as pulling the package from npm:</p><pre>npm install langchainjs-box</pre><h4>Authentication Options</h4><p>The langchainjs-box<strong> </strong>loader supports multiple authentication methods through the BoxAuth helper class:</p><ul><li>Developer token (best for quick prototyping):</li></ul><pre>import { BoxLoader, BoxAuth, BoxAuthType } from &#39;langchainjs-box&#39;;<br><br>const auth = new BoxAuth({<br>  authType: BoxAuthType.TOKEN,<br>  boxDeveloperToken: &#39;DEVELOPER_TOKEN&#39;<br>});</pre><ul><li>JWT (either with a service account or a specified user):</li></ul><pre>import { BoxLoader, BoxAuth, BoxAuthType } from &#39;langchainjs-box&#39;;<br><br>const auth = new BoxAuth({<br>  authType: BoxAuthType.JWT,<br>  boxJwtPath: &#39;./path/to/jwt-config.json&#39;,<br>  boxUserId: &#39;USER_ID&#39;<br>});</pre><ul><li>CCG (also with a service account or a specified user):</li></ul><pre>import { BoxLoader, BoxAuth, BoxAuthType } from &#39;langchainjs-box&#39;;<br><br>const auth = new BoxAuth({<br>  authType: BoxAuthType.CCG,<br>  boxClientId: &#39;CLIENT_ID&#39;,<br>  boxClientSecret: &#39;CLIENT_SECRET&#39;,<br>  boxEnterpriseId: &#39;ENTERPRISE_ID&#39;<br>});</pre><p>Check project <a href="https://www.npmjs.com/package/langchainjs-box">documentation</a> for remaining authentication code examples.</p><h4>Load files or entire folders</h4><p>Once you tackle authentication, it’s time to load content. langchainjs-box<strong> </strong>loader gives you flexibility:</p><ul><li>You can <strong>load specific files</strong> by providing an array of file IDs.</li></ul><pre>import { BoxLoader, BoxAuth, BoxAuthType } from &#39;langchainjs-box&#39;;<br><br>const auth = new BoxAuth({<br>  authType: BoxAuthType.TOKEN,<br>  boxDeveloperToken: &#39;DEVELOPER_TOKEN&#39;<br>});<br><br>const loader = new BoxLoader({<br>  boxAuth: auth,<br>  boxFileIds: [&#39;FILE_ID_1&#39;, &#39;FILE_ID_2&#39;],<br>  characterLimit: 10000  // Optional, defaults to no limit<br>});<br><br>const docs = await loader.load();</pre><ul><li><strong>Load entire folders</strong> with a single folder ID.</li></ul><pre>const loader = new BoxLoader({<br>  boxAuth: auth,<br>  boxFolderId: &#39;FOLDER_ID&#39;<br>});<br><br>const docs = await loader.load();</pre><ul><li><strong>Recursively load folder content </strong>to include all subfolders and files.</li></ul><pre>const loader = new BoxLoader({<br>  boxAuth: auth,<br>  boxFolderId: &#39;FOLDER_ID&#39;,<br>  recursive: true,  // Optional, defaults to false<br>  characterLimit: 10000  // Optional, defaults to no limit<br>});<br><br>const docs = await loader.load();</pre><ul><li><strong>Or lazy load content</strong>, allowing you to process documents one at a time.</li></ul><pre>const loader = new BoxLoader({<br>  boxAuth: auth,<br>  boxFolderId: &#39;FOLDER_ID&#39;<br>});<br><br>for await (const doc of loader.lazyLoad()) {<br>  // Process each document<br>}</pre><h3>Building a RAG Application</h3><p>Let’s take a look at a complete example of building a RAG application with LangChain.js and langchainjs-box<strong>. </strong>First, create environment variables:</p><pre>OPENAI_API_KEY=YOUR_KEY<br>BOX_FILE_IDS=FILE_ID<br>CHAR_LIMIT=1000<br>BOX_DEVELOPER_TOKEN=YOUR_TOKEN</pre><p>This example loads documents from Box, chunks them, creates embeddings, and answers questions using retrieval-augmented generation leveraging OpenAI model:</p><pre>import &#39;dotenv/config&#39;;<br>import { createRequire } from &#39;module&#39;;<br>const require = createRequire(import.meta.url);<br>const { BoxLoader, BoxAuth, BoxAuthType } = require(&#39;langchainjs-box&#39;);<br>import { RecursiveCharacterTextSplitter } from &#39;@langchain/textsplitters&#39;;<br>import { ChatOpenAI, OpenAIEmbeddings } from &#39;@langchain/openai&#39;;<br>import { MemoryVectorStore } from &#39;langchain/vectorstores/memory&#39;;<br>import { RunnableSequence } from &#39;@langchain/core/runnables&#39;;<br>import { StringOutputParser } from &#39;@langchain/core/output_parsers&#39;;<br><br>// You can use other authentication methods<br>async function loadBoxDocuments() {<br>  const developerToken = process.env.BOX_DEVELOPER_TOKEN;<br>  const boxFileIds = (process.env.BOX_FILE_IDS || &#39;&#39;).split(&#39;,&#39;).map(s =&gt; s.trim()).filter(Boolean);<br>  const boxFolderId = process.env.BOX_FOLDER_ID?.trim();<br><br>  let auth;<br>  if (developerToken) {<br>    auth = new BoxAuth({<br>      authType: BoxAuthType.TOKEN,<br>      boxDeveloperToken: developerToken<br>    });<br>  }<br><br>  const loader = new BoxLoader({<br>    boxAuth: auth,<br>    boxFileIds: boxFileIds.length ? boxFileIds : undefined,<br>    characterLimit: process.env.CHAR_LIMIT ? Number(process.env.CHAR_LIMIT) : undefined<br>  });<br><br>  return loader.load();<br>}<br><br>async function main() {<br>  const openaiApiKey = process.env.OPENAI_API_KEY;<br>  if (!openaiApiKey) {<br>    throw new Error(&#39;Missing OPENAI_API_KEY in environment&#39;);<br>  }<br>  if (!process.env.BOX_DEVELOPER_TOKEN &amp;&amp; !process.env.BOX_FILE_IDS &amp;&amp; !process.env.BOX_FOLDER_ID) {<br>    throw new Error(&#39;Provide BOX_DEVELOPER_TOKEN and either BOX_FILE_IDS (comma-separated) or BOX_FOLDER_ID&#39;);<br>  }<br><br>  console.log(&#39;Loading documents from Box...&#39;);<br>  const docs = await loadBoxDocuments();<br>  console.log(`Loaded ${docs.length} documents`);<br><br>  const splitter = new RecursiveCharacterTextSplitter({<br>    chunkSize: 1000,<br>    chunkOverlap: 200<br>  });<br>  const splits = await splitter.splitDocuments(docs);<br>  const cleanSplits = splits.filter(d =&gt; d.pageContent &amp;&amp; d.pageContent.trim().length &gt; 0 &amp;&amp; !d.pageContent.trim().startsWith(&#39;[Error&#39;));<br>  console.log(`Created ${cleanSplits.length} clean chunks (from ${splits.length})`);<br><br>  const embeddings = new OpenAIEmbeddings({ apiKey: openaiApiKey, model: &#39;text-embedding-3-small&#39; });<br>  const vectorstore = await MemoryVectorStore.fromDocuments(cleanSplits, embeddings);<br>  const retriever = vectorstore.asRetriever({ searchType: &#39;mmr&#39;, searchKwargs: { fetchK: 20 }, k: 8 });<br><br>  const question = process.env.QUESTION || &#39;What are the key points in these documents?&#39;;<br><br>  const prompt = (docsText, q) =&gt; `You are a helpful assistant.<br>Use the provided context to answer the question.<br>If the answer is not in the context, say you don&#39;t know.<br><br>Context:<br>${docsText}<br><br>Question: ${q}<br>Answer:`;<br><br>  const model = new ChatOpenAI({ model: &#39;gpt-4o-mini&#39;, temperature: 0, apiKey: openaiApiKey });<br>  const chain = RunnableSequence.from([<br>    async (input) =&gt; {<br>      const retrieved = await retriever.getRelevantDocuments(input.question);<br>      const context = retrieved.map(d =&gt; d.pageContent).join(&#39;\n\n&#39;);<br>      console.log(&#39;Context:&#39;, context);<br>      return { promptText: prompt(context, input.question) };<br>    },<br>    (x) =&gt; model.invoke(x.promptText),<br>    new StringOutputParser()<br>  ]);<br><br>  console.log(&#39;Asking question:&#39;, question);<br>  const answer = await chain.invoke({ question });<br>  console.log(&#39;\nAnswer:\n&#39;, answer);<br>}<br><br>main().catch(err =&gt; {<br>  console.error(err);<br>  process.exit(1);<br>});</pre><p>I am excited to hear your feedback and learn how you’re leveraging Box loader for LangChain.js. Check out the langchainjs-box<strong> </strong>package on npm and explore the <a href="https://www.npmjs.com/package/langchainjs-box">full documentation</a>. As LangChain recently announced a new major version the package will be soon updated to support it.</p><p>If you have additional requests, suggestions or you’d like to share examples of apps that you’ve built leveraging this package, let us know on <a href="https://community.box.com/">Box Developer Community</a> forum.</p><p>Happy building! 🚀</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d7c45a13957b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/box-developer-blog/create-rag-powered-apps-with-box-loader-for-langchain-js-d7c45a13957b">Create RAG-powered apps with Box loader for LangChain.js</a> was originally published in <a href="https://medium.com/box-developer-blog">Box Developer Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>