<?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[Stories by Asaki Sakamoto on Medium]]></title>
        <description><![CDATA[Stories by Asaki Sakamoto on Medium]]></description>
        <link>https://medium.com/@asakisakamoto02?source=rss-d1e94386bbd1------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*9pv7RqsSjVMnUtR7GTcC-Q.png</url>
            <title>Stories by Asaki Sakamoto on Medium</title>
            <link>https://medium.com/@asakisakamoto02?source=rss-d1e94386bbd1------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 17:40:04 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@asakisakamoto02/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[How to Do Kafka Testing in Postman]]></title>
            <link>https://medium.com/towards-agi/how-to-do-kafka-testing-in-postman-a4a8433418e0?source=rss-d1e94386bbd1------2</link>
            <guid isPermaLink="false">https://medium.com/p/a4a8433418e0</guid>
            <category><![CDATA[kafka]]></category>
            <category><![CDATA[postman]]></category>
            <dc:creator><![CDATA[Asaki Sakamoto]]></dc:creator>
            <pubDate>Tue, 13 May 2025 03:43:29 GMT</pubDate>
            <atom:updated>2025-05-13T03:43:29.123Z</atom:updated>
            <content:encoded><![CDATA[<p>Apache Kafka has become the backbone of modern real-time data pipelines, enabling high-throughput, fault-tolerant, and scalable event streaming. As Kafka’s adoption grows, so does the critical need for robust testing to ensure data integrity, system reliability, and correct application behavior. While dedicated Kafka tools exist, many teams already leverage Postman for their API testing needs. This article explores how you can extend Postman’s capabilities to test Kafka interactions, primarily by using a Kafka REST Proxy.</p><p>Before we dive into the specifics, it’s worth considering Apidog as a powerful, integrated, and often more cost-effective solution. Apidog aims to be an all-in-one platform, covering the entire API lifecycle from design, debugging, and testing to documentation and mocking. Users often praise its collaborative features, intuitive interface, and more competitive pricing structure, especially for teams.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*3f7AnNvhWrZ9pI3r.png" /></figure><p>While Postman offers a robust free tier, its advanced features and team collaboration can become costly. Apidog presents itself as a compelling alternative that streamlines workflows by reducing the need to switch between multiple tools, potentially offering better value and a more seamless experience for developers looking for a comprehensive API solution.</p><p><a href="https://bit.ly/4cXRPww">Apidog An integrated platform for API design, debugging, development, mock, and testing</a></p><h3>Why Test Kafka?</h3><p>Before diving into the “how,” let’s briefly touch upon the “why”:</p><ol><li>Data Integrity: Ensure messages are produced and consumed correctly, without loss or corruption.</li><li>Producer Logic: Verify that your applications are sending the right data, with correct keys, values, and headers, to the intended topics.</li><li>Consumer Logic: Confirm that consumers process messages as expected, handle different message types, and manage offsets correctly.</li><li>Schema Evolution: Test how producers and consumers react to changes in message schemas (especially when using Avro, Protobuf with a Schema Registry).</li><li>Error Handling: Validate retry mechanisms, dead-letter queue (DLQ) processing, and overall system resilience in failure scenarios.</li><li>End-to-End Flow: Ensure the entire pipeline, from message production to consumption and subsequent actions, works seamlessly.</li></ol><h3>Why Postman for Kafka Testing?</h3><p>Postman isn’t a native Kafka client. Kafka communicates over a binary protocol on TCP/IP, while Postman speaks HTTP. So, how do we bridge this gap? The answer lies in a Kafka REST Proxy.</p><p>Advantages of using Postman (with a REST Proxy):</p><ul><li>Familiarity: Many teams already use Postman, reducing the learning curve.</li><li>UI-Driven: Easy to construct requests, view responses, and manage test cases for those less comfortable with command-line tools.</li><li>Environment and Collection Management: Postman’s features for organizing tests and managing different environments (dev, staging, prod) are highly beneficial.</li><li>Scripting Capabilities: JavaScript-based pre-request scripts and test scripts allow for dynamic data generation, assertions, and workflow chaining.</li><li>Integration with CI/CD: Postman collections can be run via Newman (Postman’s command-line runner) and integrated into CI/CD pipelines.</li></ul><p>The most common and well-supported REST Proxy is Confluent’s Kafka REST Proxy. It provides a RESTful interface to your Kafka cluster, allowing you to produce messages, consume messages, and query cluster metadata via HTTP requests.</p><h3>Prerequisites</h3><ol><li>Apache Kafka Cluster: A running Kafka cluster. For local development, a Docker-based setup is recommended.</li><li>Kafka REST Proxy: Deployed and configured to connect to your Kafka cluster. This will also typically run in Docker.</li><li>Postman: The latest version installed.</li><li>Basic Kafka Knowledge: Understanding of topics, partitions, brokers, producers, and consumers.</li></ol><h3>Setting Up Your Local Environment with Docker</h3><p>Here’s a simple docker-compose.yml to get Zookeeper, Kafka, and the Confluent REST Proxy running locally:</p><pre>version: &#39;3.7&#39;</pre><pre>services:<br>  zookeeper:<br>    image: confluentinc/cp-zookeeper:7.3.0<br>    container_name: zookeeper<br>    ports:<br>      - &quot;2181:2181&quot;<br>    environment:<br>      ZOOKEEPER_CLIENT_PORT: 2181<br>      ZOOKEEPER_TICK_TIME: 2000</pre><pre>  kafka:<br>    image: confluentinc/cp-kafka:7.3.0<br>    container_name: kafka<br>    ports:<br>      - &quot;9092:9092&quot; # For direct Kafka clients<br>      - &quot;29092:29092&quot; # For host access if needed<br>    depends_on:<br>      - zookeeper<br>    environment:<br>      KAFKA_BROKER_ID: 1<br>      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181<br>      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka:9092,PLAINTEXT_HOST://localhost:29092<br>      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: PLAINTEXT:PLAINTEXT,PLAINTEXT_HOST:PLAINTEXT<br>      KAFKA_INTER_BROKER_LISTENER_NAME: PLAINTEXT<br>      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1<br>      KAFKA_GROUP_INITIAL_REBALANCE_DELAY_MS: 0<br>      KAFKA_CONFLUENT_LICENSE_TOPIC_REPLICATION_FACTOR: 1 # Required for Confluent images<br>      KAFKA_CONFLUENT_BALANCER_TOPIC_REPLICATION_FACTOR: 1 # Required for Confluent images<br>      KAFKA_TRANSACTION_STATE_LOG_MIN_ISR: 1             # Required for Confluent images<br>      KAFKA_TRANSACTION_STATE_LOG_REPLICATION_FACTOR: 1  # Required for Confluent images<br></pre><pre>  kafka-rest-proxy:<br>    image: confluentinc/cp-kafka-rest:7.3.0<br>    container_name: kafka-rest-proxy<br>    ports:<br>      - &quot;8082:8082&quot;<br>    depends_on:<br>      - kafka<br>      - zookeeper<br>    environment:<br>      KAFKA_REST_HOST_NAME: kafka-rest-proxy<br>      KAFKA_REST_BOOTSTRAP_SERVERS: &#39;kafka:9092&#39;<br>      KAFKA_REST_LISTENERS: &quot;http://0.0.0.0:8082&quot;<br>      KAFKA_REST_SCHEMA_REGISTRY_URL: &#39;http://schema-registry:8081&#39; # Optional: Add if using Schema Registry</pre><p>Save this as docker-compose.yml and run docker-compose up -d.<br>Your Kafka REST Proxy will be available at <a href="http://localhost:8082.">http://localhost:8082.</a></p><h3>Structuring Tests in Postman</h3><ol><li>Create a Collection: Name it something like “Kafka Tests.”</li><li>Use Environments: Create a Postman environment (e.g., “Kafka Local Dev”) and define variables:</li></ol><ul><li>kafka_rest_proxy_url: <a href="http://localhost:8082/">http://localhost:8082</a></li><li>test_topic: my_test_topic (or any topic you want to use)</li><li>consumer_group: my_test_consumer_group</li></ul><h3>Part 1: Testing Producers (Sending Messages)</h3><p>To send messages to a Kafka topic, you’ll make a POST request to the /topics/{topic_name} endpoint of the REST Proxy.</p><p>Request Setup:</p><ul><li>Method: POST</li><li>URL: {{kafka_rest_proxy_url}}/topics/{{test_topic}}</li><li>Headers:</li><li>Content-Type: application/vnd.kafka.json.v2+json (if sending JSON messages)</li><li>Accept: application/vnd.kafka.v2+json</li><li>Body (Raw — JSON):</li><li>The body structure depends on whether you’re sending a single record or multiple records, and if you’re specifying keys.</li><li>Simple Value (Single Record):</li><li>{ &quot;records&quot;: [ { &quot;value&quot;: {&quot;message&quot;: &quot;Hello from Postman!&quot;, &quot;timestamp&quot;: &quot;{{$isoTimestamp}}&quot;} } ] }</li><li>Key and Value (Single Record):</li><li>{ &quot;records&quot;: [ { &quot;key&quot;: &quot;user123&quot;, &quot;value&quot;: {&quot;event&quot;: &quot;login&quot;, &quot;userId&quot;: &quot;user123&quot;, &quot;status&quot;: &quot;success&quot;} } ] }</li><li>Multiple Records:</li><li>{ &quot;records&quot;: [ { &quot;key&quot;: &quot;order001&quot;, &quot;value&quot;: {&quot;item&quot;: &quot;laptop&quot;, &quot;quantity&quot;: 1} }, { &quot;key&quot;: &quot;order002&quot;, &quot;value&quot;: {&quot;item&quot;: &quot;mouse&quot;, &quot;quantity&quot;: 2} } ] }</li><li>(Note: {{$isoTimestamp}} is a Postman dynamic variable.)</li></ul><p>Postman Tests (Assertions):</p><p>In the “Tests” tab of your Postman request, you can add JavaScript assertions:</p><pre>pm.test(&quot;Status code is 200&quot;, function () {<br>    pm.response.to.have.status(200);<br>});</pre><pre>pm.test(&quot;Response body contains offsets&quot;, function () {<br>    const responseBody = pm.response.json();<br>    pm.expect(responseBody).to.have.property(&#39;offsets&#39;);<br>    pm.expect(responseBody.offsets).to.be.an(&#39;array&#39;).that.is.not.empty;<br>    pm.expect(responseBody.offsets[0]).to.have.property(&#39;partition&#39;);<br>    pm.expect(responseBody.offsets[0]).to.have.property(&#39;offset&#39;);<br>    console.log(&quot;Message sent to partition: &quot; + responseBody.offsets[0].partition +<br>                &quot;, offset: &quot; + responseBody.offsets[0].offset);<br>});</pre><pre>pm.test(&quot;Key offset error code is null or 0&quot;, function () {<br>    const responseBody = pm.response.json();<br>    if (responseBody.key_schema_id !== null || responseBody.value_schema_id !== null) {<br>        // This part is more relevant for Avro/Schema Registry<br>        // For JSON, offsets are the primary concern<br>    }<br>    responseBody.offsets.forEach(offsetInfo =&gt; {<br>        pm.expect(offsetInfo.error_code, &quot;Error code for an offset should be null or 0&quot;).to.be.oneOf([null, 0]);<br>        if(offsetInfo.error_code !== null &amp;&amp; offsetInfo.error_code !== 0) {<br>            console.error(&quot;Error producing message: &quot; + offsetInfo.error);<br>        }<br>    });<br>});</pre><h3>Part 2: Testing Consumers (Reading Messages)</h3><p>Consuming messages via the REST Proxy is a multi-step process:</p><ol><li>Create a Consumer Instance:</li></ol><ul><li>Method: POST</li><li>URL: {{kafka_rest_proxy_url}}/consumers/{{consumer_group}}</li><li>Headers:</li><li>Content-Type: application/vnd.kafka.v2+json</li><li>Body (Raw — JSON):</li><li>{ &quot;name&quot;: &quot;my_postman_consumer_instance&quot;, // A unique name for this consumer instance &quot;format&quot;: &quot;json&quot;, // The format of messages you expect (json, avro, binary) &quot;auto.offset.reset&quot;: &quot;earliest&quot; // Start consuming from the beginning of the topic // &quot;auto.commit.enable&quot;: &quot;false&quot; // Optionally disable auto-commit for manual control }</li><li>Tests (to capture base_uri):</li><li>pm.test(&quot;Status code is 200&quot;, function () { pm.response.to.have.status(200); }); const responseBody = pm.response.json(); pm.environment.set(&quot;consumer_instance_base_uri&quot;, responseBody.base_uri); console.log(&quot;Consumer instance created: &quot; + responseBody.instance_id); console.log(&quot;Base URI: &quot; + responseBody.base_uri);</li><li>This script saves the base_uri from the response to an environment variable, which is crucial for subsequent calls.</li></ul><ol><li>Subscribe the Consumer to a Topic:</li></ol><ul><li>Method: POST</li><li>URL: {{consumer_instance_base_uri}}/subscription</li><li>Headers:</li><li>Content-Type: application/vnd.kafka.v2+json</li><li>Body (Raw — JSON):</li><li>{ &quot;topics&quot;: [&quot;{{test_topic}}&quot;] // Array of topics to subscribe to }</li><li>Tests:</li><li>pm.test(&quot;Status code is 204 (No Content) or 200 (OK)&quot;, function () { pm.expect(pm.response.code).to.be.oneOf([200, 204]); }); console.log(&quot;Subscribed to topic: {{test_topic}}&quot;);</li></ul><ol><li>Fetch (Poll for) Messages:</li></ol><ul><li>Method: GET</li><li>URL: {{consumer_instance_base_uri}}/records?timeout=5000&amp;max_bytes=300000</li><li>timeout: How long the server should wait for messages if the buffer is empty (milliseconds).</li><li>max_bytes: Maximum number of bytes to fetch.</li><li>Headers:</li><li>Accept: application/vnd.kafka.json.v2+json (or the format you expect)</li><li>Tests:</li><li>pm.test(&quot;Status code is 200&quot;, function () { pm.response.to.have.status(200); }); const messages = pm.response.json(); if (messages.length &gt; 0) { console.log(&quot;Received &quot; + messages.length + &quot; messages.&quot;); pm.test(&quot;Messages received are valid&quot;, function() { messages.forEach(function(msg, index) { console.log(`Message ${index + 1} Key:`, msg.key); console.log(`Message ${index + 1} Value:`, msg.value); console.log(`Message ${index + 1} Partition:`, msg.partition); console.log(`Message ${index + 1} Offset:`, msg.offset); pm.expect(msg).to.have.property(&#39;topic&#39;, pm.environment.get(&quot;test_topic&quot;)); pm.expect(msg).to.have.property(&#39;value&#39;); // Add more specific assertions about the message content // For example, if you sent {&quot;event&quot;: &quot;login&quot;, ...} if (msg.key === &quot;user123&quot; &amp;&amp; msg.value &amp;&amp; msg.value.event === &quot;login&quot;) { pm.expect(msg.value.status).to.equal(&quot;success&quot;); } }); }); } else { console.log(&quot;No new messages received.&quot;); // This is not necessarily a failure, depends on test case pm.test(&quot;No messages received (as expected or observed)&quot;, function() { pm.expect(messages.length).to.equal(0); }); }</li></ul><ol><li>(Optional) Commit Offsets:<br>If you set auto.commit.enable to false when creating the consumer, you need to commit offsets manually.</li></ol><ul><li>Method: POST</li><li>URL: {{consumer_instance_base_uri}}/offsets</li><li>Headers:</li><li>Content-Type: application/vnd.kafka.v2+json</li><li>(No Body needed if committing current offsets, or specify partitions/offsets in body)</li><li>Tests:</li><li>pm.test(&quot;Status code is 200 or 204&quot;, function () { pm.expect(pm.response.code).to.be.oneOf([200, 204]); }); console.log(&quot;Offsets committed.&quot;);</li></ul><ol><li>Delete the Consumer Instance (Cleanup):<br>It’s good practice to delete consumer instances when you’re done to free up resources.</li></ol><ul><li>Method: DELETE</li><li>URL: {{consumer_instance_base_uri}}</li><li>Headers:</li><li>Accept: application/vnd.kafka.v2+json</li><li>Tests:</li><li>pm.test(&quot;Status code is 204 (No Content)&quot;, function () { pm.response.to.have.status(204); }); console.log(&quot;Consumer instance deleted.&quot;); pm.environment.unset(&quot;consumer_instance_base_uri&quot;); // Clean up env var</li></ul><h3>Advanced Considerations</h3><ul><li>Data Serialization (Avro, Protobuf):<br>If your Kafka messages use Avro or Protobuf with a Schema Registry, the Content-Type and Accept headers will change (e.g., application/vnd.kafka.avro.v2+json). The REST Proxy will handle serialization/deserialization if it&#39;s configured with the Schema Registry URL.</li><li>Producer Header: Content-Type: application/vnd.kafka.avro.v2+json</li><li>Producer Body:</li><li>{ &quot;value_schema&quot;: &quot;{\&quot;type\&quot;:\&quot;record\&quot;,\&quot;name\&quot;:\&quot;UserInfo\&quot;,\&quot;fields\&quot;:[{\&quot;name\&quot;:\&quot;username\&quot;,\&quot;type\&quot;:\&quot;string\&quot;}]}&quot;, // Or use schema_id &quot;records&quot;: [{&quot;value&quot;: {&quot;username&quot;: &quot;testavro&quot;}}] }</li><li>Consumer Header: Accept: application/vnd.kafka.avro.v2+json</li><li>Schema Registry Integration:<br>Ensure your kafka-rest-proxy service in docker-compose.yml has KAFKA_REST_SCHEMA_REGISTRY_URL set. You can also test schema registration and compatibility through the Schema Registry&#39;s own REST API (usually on port 8081).</li><li>Testing Headers:<br>Kafka messages can have headers. The REST Proxy supports sending and receiving these.</li><li>Producer Body with Headers:</li><li>{ &quot;records&quot;: [ { &quot;value&quot;: {&quot;message&quot;: &quot;Hello with headers!&quot;}, &quot;headers&quot;: [ {&quot;traceId&quot;: &quot;abc-123-xyz&quot;}, {&quot;sourceSystem&quot;: &quot;postman-test&quot;} ] } ] }</li><li>When consuming, headers will appear as an array of key-value objects in the message.</li><li>Error Handling Tests:<br>Simulate error conditions:</li><li>Send malformed messages.</li><li>Try to consume from a non-existent topic.</li><li>Test consumer behavior when a dependent service is down.</li><li>Test Data Management:<br>Use Postman’s dynamic variables ({{$randomInt}}, {{$guid}}, {{$timestamp}}) or CSV/JSON data files with the Collection Runner for data-driven testing.</li><li>Automation with Newman:<br>Export your Postman collection and environment. Run tests from the command line using Newman:<br>newman run &quot;Kafka Tests.postman_collection.json&quot; -e &quot;Kafka Local Dev.postman_environment.json&quot;<br>This is ideal for CI/CD integration.</li><li>Security:<br>If your Kafka REST Proxy is secured (e.g., with TLS/SSL or authentication), configure Postman’s authorization settings accordingly.</li></ul><h3>Limitations of Postman for Kafka Testing</h3><ul><li>Not Real-time Streaming: Postman polls for messages. It doesn’t maintain a persistent connection like a native Kafka consumer. This makes it less suitable for testing real-time stream processing logic that relies on continuous data flow.</li><li>State Management: While Postman variables help, managing complex consumer state or long-running test scenarios can be cumbersome.</li><li>Performance Testing: Postman is not designed for high-load performance testing of Kafka. Dedicated tools are better for this.</li><li>Abstraction Layer: You’re testing Kafka <em>through</em> the REST Proxy. While usually fine, it’s one more layer that could obscure certain Kafka-specific behaviors or issues.</li></ul><h3>Conclusion</h3><p>Testing Kafka with Postman via a REST Proxy offers a convenient and accessible way for teams to validate their event-driven architectures, especially if Postman is already part of their testing ecosystem. By structuring requests to produce messages and following the multi-step consumer process, testers can verify data integrity, schema handling, and basic producer/consumer logic. While it has limitations for real-time or high-performance testing, Postman provides a solid foundation for functional Kafka testing, enabling developers and QAs to build more reliable and robust data pipelines. Remember to leverage Postman’s scripting, environment, and collection features to create maintainable and effective Kafka test suites.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a4a8433418e0" width="1" height="1" alt=""><hr><p><a href="https://medium.com/towards-agi/how-to-do-kafka-testing-in-postman-a4a8433418e0">How to Do Kafka Testing in Postman</a> was originally published in <a href="https://medium.com/towards-agi">Towards AGI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Install Postman on Linux]]></title>
            <link>https://medium.com/towards-agi/how-to-install-postman-on-linux-d091032a5dd9?source=rss-d1e94386bbd1------2</link>
            <guid isPermaLink="false">https://medium.com/p/d091032a5dd9</guid>
            <category><![CDATA[postman]]></category>
            <category><![CDATA[linux]]></category>
            <dc:creator><![CDATA[Asaki Sakamoto]]></dc:creator>
            <pubDate>Tue, 13 May 2025 03:43:25 GMT</pubDate>
            <atom:updated>2025-05-13T03:43:25.983Z</atom:updated>
            <content:encoded><![CDATA[<p>The world of API (Application Programming Interface) development and testing is dynamic and ever-evolving. For years, Postman has been a dominant force, a go-to tool for developers working with APIs. However, the landscape is rich with alternatives, and one notable contender gaining traction is Apidog.</p><p>Before we dive into the specifics of installing Postman on Linux, it’s worth considering Apidog as a powerful, integrated, and often more cost-effective solution. Apidog aims to be an all-in-one platform, covering the entire API lifecycle from design, debugging, and testing to documentation and mocking. Users often praise its collaborative features, intuitive interface, and more competitive pricing structure, especially for teams.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*aiKuoHxDDqwsklKY.png" /></figure><p>While Postman offers a robust free tier, its advanced features and team collaboration can become costly. Apidog presents itself as a compelling alternative that streamlines workflows by reducing the need to switch between multiple tools, potentially offering better value and a more seamless experience for developers looking for a comprehensive API solution.</p><p><a href="https://bit.ly/4cXRPww">Apidog An integrated platform for API design, debugging, development, mock, and testing</a></p><p>Now, let’s focus on Postman, a widely-used platform for building, testing, and documenting APIs. Its user-friendly interface and extensive feature set have made it a staple for developers worldwide. If you’re a Linux user, this guide will walk you through various methods to install Postman on your system, ensuring you can get up and running quickly.</p><h3>What is Postman?</h3><p>Postman is an API platform that allows developers to design, build, test, and iterate on their APIs. It started as a simple REST client and has evolved into a full-featured collaboration platform for API development. Key features include:</p><ul><li>Request Building: Create and send HTTP requests (GET, POST, PUT, DELETE, etc.) with various parameters, headers, and body data.</li><li>Testing: Write and run automated tests for your APIs, checking for response status, data integrity, and performance.</li><li>Collections: Organize your API requests into collections for better management and sharing.</li><li>Environments: Manage different environments (e.g., development, staging, production) with specific variables.</li><li>Documentation: Automatically generate and publish API documentation.</li><li>Mock Servers: Create mock servers to simulate API endpoints before they are fully developed.</li><li>Collaboration: Share collections, environments, and documentation with team members.</li></ul><h3>Why Install Postman on Linux?</h3><p>Linux is a popular operating system for developers due to its flexibility, command-line interface, and open-source nature. Having Postman on your Linux machine allows you to:</p><ul><li>Develop and test APIs directly within your development environment.</li><li>Integrate Postman into your Linux-based CI/CD pipelines using Newman (Postman’s command-line Collection Runner).</li><li>Leverage the power of the Linux terminal alongside Postman for a comprehensive development workflow.</li></ul><h3>Prerequisites</h3><p>Before installing Postman, ensure your Linux system meets the following basic requirements:</p><ul><li>A modern Linux distribution (e.g., Ubuntu, Fedora, Debian, CentOS, Mint).</li><li>Sufficient disk space (at least a few hundred MBs).</li><li>An active internet connection to download the installer or packages.</li><li>sudo or root privileges if installing system-wide or using package managers that require it.</li></ul><h3>Installation Methods</h3><p>There are primarily two recommended ways to install Postman on Linux:</p><ol><li>Using Snap (Recommended by Postman)</li><li>Manually via the tar.gz archive</li></ol><p>Let’s explore each method in detail.</p><h4>Method 1: Installing Postman using Snap</h4><p>Snaps are containerized software packages that are easy to create and install. They work across many Linux distributions and come with auto-updating features. Postman officially recommends installing via Snap for Linux users.</p><p>Step 1: Ensure Snapd is Installed</p><p>Snapd is the background service that manages snaps. Most modern Ubuntu distributions come with Snapd pre-installed. If you’re on another distribution or an older Ubuntu version, you might need to install it first.</p><ul><li>For Ubuntu and Debian-based systems:</li><li>sudo apt update sudo apt install snapd</li><li>For Fedora:</li><li>sudo dnf install snapd sudo ln -s /var/lib/snapd/snap /snap # For classic snap support</li><li>For Arch Linux:</li><li>sudo pacman -S snapd sudo systemctl enable --now snapd.socket sudo ln -s /var/lib/snapd/snap /snap # For classic snap support</li><li>For other distributions: Refer to the official Snapcraft documentation for instructions on installing snapd.</li></ul><p>You might need to log out and log back in or restart your system for snapd to be fully active.</p><p>Step 2: Install Postman using Snap</p><p>Once Snapd is set up, you can install Postman with a single command:</p><pre>sudo snap install postman</pre><p>This command will download and install the latest version of Postman. The installation process might take a few minutes depending on your internet speed.</p><p>Step 3: Launch Postman</p><p>After the installation is complete, you can launch Postman from your application menu or by running the following command in your terminal:</p><pre>postman</pre><p>Updating Postman via Snap</p><p>Snaps usually update automatically in the background. You can also manually check for updates:</p><pre>sudo snap refresh postman</pre><p>If a new version is available, it will be downloaded and installed.</p><p>Removing Postman via Snap</p><p>If you need to uninstall Postman installed via Snap, use:</p><pre>sudo snap remove postman</pre><h4>Method 2: Installing Postman Manually using the tar.gz Archive</h4><p>This method involves downloading the Postman archive, extracting it, and optionally creating a desktop entry for easier access.</p><p>Step 1: Download the Postman Archive</p><ol><li>Go to the official Postman downloads page: <a href="https://www.postman.com/downloads/">https://www.postman.com/downloads/</a></li><li>Download the Linux version. It will typically be a tar.gz file (e.g., Postman-linux-x64.tar.gz).</li><li>Alternatively, you can use wget or curl to download it from the terminal. You&#39;ll need to find the direct download link, which can sometimes be tricky as it might be dynamically generated. A common approach is to inspect the download button on the website. For example (the exact URL might change):</li></ol><ul><li>wget https://dl.pstmn.io/download/latest/linux_64 -O postman-linux-x64.tar.gz</li></ul><ol><li>(Always verify the latest download link from the official Postman website).</li></ol><p>Step 2: Extract the Archive</p><p>Once the download is complete, open your terminal and navigate to the directory where you downloaded the file (e.g., ~/Downloads).</p><p>Extract the archive using the tar command:</p><pre>cd ~/Downloads # Or your download directory<br>tar -xzf Postman-linux-x64.tar.gz</pre><p>This will create a directory named Postman (or similar) containing the application files.</p><p>Step 3: Move the Postman Directory (Optional but Recommended)</p><p>It’s good practice to move the extracted Postman directory to a more standard location, such as /opt (for optional software packages) or ~/opt or ~/.local/share for a user-specific installation.</p><ul><li>System-wide installation (requires sudo):</li><li>sudo mv Postman /opt/</li><li>User-specific installation:</li><li>mkdir -p ~/opt # if it doesn&#39;t exist mv Postman ~/opt/ # Or # mkdir -p ~/.local/share # mv Postman ~/.local/share/</li><li>For this guide, we’ll assume you’ve moved it to /opt/Postman.</li></ul><p>Step 4: Create a Symbolic Link (Optional)</p><p>To run Postman from the terminal without navigating to its directory, you can create a symbolic link to the executable in a directory that’s in your system’s PATH, like /usr/local/bin.</p><pre>sudo ln -s /opt/Postman/Postman /usr/local/bin/postman</pre><p>If you installed it in a user directory (e.g., ~/opt/Postman), you might add a symlink to ~/.local/bin (ensure ~/.local/bin is in your PATH):</p><pre>mkdir -p ~/.local/bin<br>ln -s ~/opt/Postman/Postman ~/.local/bin/postman</pre><p>After this, you should be able to type postman in the terminal to launch the application.</p><p>Step 5: Create a Desktop Entry/Launcher (Optional)</p><p>To launch Postman from your desktop environment’s application menu, you need to create a .desktop file.</p><ol><li>Create a new file named postman.desktop in ~/.local/share/applications/ (for user-specific) or /usr/share/applications/ (for system-wide, requires sudo).</li></ol><ul><li>nano ~/.local/share/applications/postman.desktop</li></ul><ol><li>Or, if you have gedit or another text editor:</li></ol><ul><li>gedit ~/.local/share/applications/postman.desktop</li></ul><ol><li>Paste the following content into the file. Adjust the Exec and Icon paths if you installed Postman in a different location than /opt/Postman. The icon is usually within the Postman application directory.</li></ol><ul><li><strong>[Desktop Entry]</strong> Name=Postman GenericName=API Client Comment=Develop, test, and document APIs Exec=/opt/Postman/Postman %U Terminal=false Type=Application Icon=/opt/Postman/app/resources/app/assets/icon.png Categories=Development;Network; StartupWMClass=Postman</li><li>Exec: Path to the Postman executable. If you used ~/opt/Postman, change this to ~/opt/Postman/Postman %U.</li><li>Icon: Path to the Postman icon. The exact path might vary slightly depending on the Postman version, so check inside your /opt/Postman (or equivalent) directory. A common location is app/resources/app/assets/icon.png relative to the Postman installation directory.</li></ul><ol><li>Save the file and close the editor.</li><li>You might need to update your desktop database for the new entry to appear:</li></ol><ul><li>update-desktop-database ~/.local/share/applications</li></ul><ol><li>If you installed it system-wide, you might not need to run this, or it might be sudo update-desktop-database /usr/share/applications.</li></ol><p>After these steps, Postman should appear in your application launcher.</p><p>Updating Manually Installed Postman</p><p>When a new version of Postman is released, you’ll need to repeat the download and extraction process:</p><ol><li>Download the new tar.gz file.</li><li>Remove the old Postman directory (e.g., sudo rm -rf /opt/Postman or rm -rf ~/opt/Postman).</li><li>Extract the new archive and move it to the same location.<br>The symbolic link and desktop entry (if created with absolute paths) should continue to work, provided you replace the Postman folder with the new version in the same location and with the same name.</li></ol><p>Removing Manually Installed Postman</p><ol><li>Delete the Postman directory:</li></ol><ul><li>If installed in /opt: sudo rm -rf /opt/Postman</li><li>If installed in ~/opt: rm -rf ~/opt/Postman</li></ul><ol><li>Remove the symbolic link (if created):</li></ol><ul><li>sudo rm /usr/local/bin/postman</li><li>rm ~/.local/bin/postman</li></ul><ol><li>Remove the desktop entry (if created):</li></ol><ul><li>rm ~/.local/share/applications/postman.desktop</li><li>sudo rm /usr/share/applications/postman.desktop</li><li>And update the desktop database again if needed.</li></ul><h3>Launching Postman</h3><p>Regardless of the installation method:</p><ul><li>Via Application Menu: Search for “Postman” in your desktop environment’s application launcher.</li><li>Via Terminal: If you installed via Snap or created a symbolic link for manual installation, simply type:</li><li>postman</li><li>If you installed manually without a symlink, navigate to the Postman installation directory and run:</li><li>./Postman</li></ul><h3>Basic Post-Installation Setup</h3><p>When you first launch Postman, you’ll typically be greeted with a welcome screen. You’ll have the option to:</p><ol><li>Create a free account or Sign In: This is highly recommended as it allows you to sync your collections, environments, history, and other data across devices. It also enables collaboration features.</li><li>Skip and go to the app: You can use Postman without an account, but your data will be stored locally and won’t be synced.</li></ol><p>Once in the app, take some time to explore the interface:</p><ul><li>Sidebar: Access collections, APIs, environments, mock servers, monitors, and history.</li><li>Builder: Where you construct and send requests, and view responses.</li><li>Header Bar: Switch between workspaces, access settings, notifications, and your profile.</li></ul><h3>Troubleshooting Common Installation Issues</h3><ul><li>Snap installation fails (“snap not found”): Ensure snapd is installed and running. You might need to restart your session or system.</li><li>Manual installation: “Permission denied” when running ./Postman: Make sure the Postman executable has execute permissions. Navigate to the Postman directory and run chmod +x Postman.</li><li>Manual installation: Postman doesn’t appear in the application menu:</li><li>Double-check the paths in your postman.desktop file, especially Exec and Icon.</li><li>Ensure the .desktop file has the correct permissions and is in the right directory (~/.local/share/applications or /usr/share/applications).</li><li>Try running update-desktop-database ~/.local/share/applications.</li><li>AppImage issues (if you chose an AppImage distribution, though tar.gz is more common for manual): If Postman were distributed as an AppImage, you’d need to make it executable (chmod +x Postman.AppImage) and then run it (./Postman.AppImage). For AppImage integration, appimaged can be used.</li><li>Missing libraries: This is rare with the official builds but can happen. Error messages in the terminal when launching Postman usually indicate missing dependencies. Search for how to install those specific libraries on your Linux distribution. Using the Snap package usually avoids this due to its containerized nature.</li></ul><h3>Conclusion</h3><p>Installing Postman on Linux is a straightforward process, whether you choose the convenience of Snap or the control of a manual installation. With Postman up and running, you’re well-equipped to tackle API development, testing, and documentation tasks efficiently on your Linux system. Remember to explore its vast features, from creating simple requests to building complex test suites and collaborating with your team. And as you navigate the API tooling landscape, keep alternatives like Apidog in mind, as they might offer features or pricing models that better suit your evolving needs. Happy API building!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d091032a5dd9" width="1" height="1" alt=""><hr><p><a href="https://medium.com/towards-agi/how-to-install-postman-on-linux-d091032a5dd9">How to Install Postman on Linux</a> was originally published in <a href="https://medium.com/towards-agi">Towards AGI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[GitMCP: Turn Any Github Repo into MCP Servers]]></title>
            <link>https://medium.com/towards-agi/gitmcp-transforming-github-repositories-into-ai-accessible-knowledge-bases-91da5ac554d0?source=rss-d1e94386bbd1------2</link>
            <guid isPermaLink="false">https://medium.com/p/91da5ac554d0</guid>
            <category><![CDATA[mcp-server]]></category>
            <category><![CDATA[mcps]]></category>
            <category><![CDATA[github]]></category>
            <dc:creator><![CDATA[Asaki Sakamoto]]></dc:creator>
            <pubDate>Fri, 11 Apr 2025 14:38:35 GMT</pubDate>
            <atom:updated>2025-04-11T14:40:09.963Z</atom:updated>
            <content:encoded><![CDATA[<p>In the evolving landscape of AI development, access to comprehensive documentation is crucial for AI assistants to provide accurate and helpful responses. GitMCP emerges as an innovative solution, bridging the gap between GitHub repositories and AI assistants by implementing the Model Context Protocol (MCP). This seamless integration enables AI systems to intelligently access, search, and interpret GitHub project documentation without any setup requirements.</p><p><a href="https://github.com/idosal/git-mcp">GitHub - idosal/git-mcp: Put an end to code hallucinations! GitMCP is a free, open-source, remote MCP server for any GitHub project</a></p><p><strong>Pro Tip:</strong> Boost your AI development workflow by integrating the <a href="https://bit.ly/41ItNSS">Apidog MCP Server</a> into your IDE. This gives your AI assistant real-time access to API specifications, enabling it to generate code, refine documentation, and streamline data model creation — all while ensuring alignment with your API design. 🚀</p><ul><li><a href="https://sebastian-petrus.medium.com/apidog-mcp-server-b477c888757e">Apidog MCP Server: The Bridge Between Your API Specifications and AI Coding Assistants</a></li><li><a href="https://www.npmjs.com/package/apidog-mcp-server">apidog-mcp-server</a></li></ul><h3>What is GitMCP?</h3><p>GitMCP is a free, open-source service that transforms any GitHub project into a remote Model Context Protocol endpoint. It allows AI assistants to access and understand project documentation through semantic search capabilities, optimizing token usage and enhancing response accuracy.</p><p>The Model Context Protocol (MCP) is a communication standard that enables AI systems to request additional context from external sources in a structured manner. GitMCP implements this protocol specifically for GitHub repositories, creating a standardized interface through which AI assistants can query and receive repository content.</p><h3>Why GitMCP Matters</h3><p>Traditional AI assistants operate with limited context windows and often lack access to up-to-date project documentation. This limitation leads to outdated responses, incomplete information, and inability to provide project-specific guidance. GitMCP solves these problems by:</p><ol><li>Providing on-demand access to current GitHub documentation</li><li>Enabling semantic search within project contents</li><li>Optimizing token usage through targeted information retrieval</li><li>Requiring zero configuration or setup from repository owners</li></ol><h3>How GitMCP Works</h3><p>GitMCP functions as an intermediary service between AI assistants and GitHub repositories. When an AI assistant needs information from a specific repository, it sends a request to GitMCP. The service then:</p><ol><li>Retrieves the relevant content from the GitHub repository</li><li>Processes the content to make it optimally consumable by AI systems</li><li>Implements semantic search capabilities to identify the most relevant information</li><li>Returns formatted responses following the MCP standard</li></ol><p>GitMCP prioritizes the llms.txt file (if available) and falls back to README.md or other documentation pages when necessary. This approach ensures that repository owners can optimize their documentation for AI consumption while maintaining backward compatibility.</p><h3>Setting Up GitMCP for Your Repository</h3><p>The beauty of GitMCP lies in its simplicity — there’s no setup required from repository owners. Any public GitHub repository is automatically accessible through GitMCP without any modifications.</p><p>To access a GitHub repository through GitMCP, you can use any of these URL formats:</p><h3>1. Standard GitHub Repositories</h3><pre>gitmcp.io/{owner}/{repo}</pre><p>For example, to access the TensorFlow repository:</p><pre>gitmcp.io/tensorflow/tensorflow</pre><h3>2. GitHub Pages Sites</h3><pre>{owner}.gitmcp.io/{repo}</pre><p>For example, to access React documentation:</p><pre>facebook.gitmcp.io/react</pre><h3>3. Dynamic Endpoint</h3><pre>gitmcp.io/docs</pre><p>This dynamic endpoint allows AI assistants to specify any repository on-the-fly, offering maximum flexibility.</p><h3>GitMCP Tools and Capabilities</h3><p>GitMCP provides several powerful tools that AI assistants can use to interact with repository content:</p><h3>1. Documentation Fetching</h3><p>The fetch_&lt;repo-name&gt;_documentation tool retrieves general documentation from the repository. It prioritizes the llms.txt file, falling back to <a href="http://readme.md/">README.md</a> or other pages if necessary. This tool is ideal for broad questions about the project.</p><h3>2. Semantic Search</h3><p>The search_&lt;repo-name&gt;_documentation tool performs semantic search across the repository&#39;s documentation based on a specific query. This capability is particularly useful for finding precise information without consuming excessive tokens.</p><h3>3. URL Content Fetching</h3><p>With the fetch_url_content tool, AI assistants can access additional resources linked within the documentation. This enables comprehensive information gathering from referenced materials.</p><h3>4. Code Search</h3><p>The search_&lt;repo-name&gt;_code tool leverages GitHub&#39;s code search API to find relevant code snippets matching search queries. This helps AI assistants provide code examples and implementation details.</p><p>When using the dynamic endpoint (gitmcp.io/docs), these tools become fetch_generic_documentation, search_generic_documentation, and search_generic_code, requiring additional owner and repository parameters.</p><h3>Practical Applications</h3><h3>Enhancing AI Development Workflows</h3><p>Developers can instruct their AI assistants to reference project documentation through GitMCP when implementing features or fixing bugs. For example:</p><p>“Help me implement authentication in my Express.js application using Passport.js. Reference the documentation via <a href="http://gitmcp.io/jaredhanson/passport.%22">gitmcp.io/jaredhanson/passport.”</a></p><h3>Providing Technical Support</h3><p>Support teams can leverage GitMCP to enable AI assistants to answer user questions based on project documentation:</p><p>“My team uses <a href="http://gitmcp.io/prisma/prisma">gitmcp.io/prisma/prisma</a> to help our support chatbot answer technical questions about our ORM implementation.”</p><h3>Educational Tools</h3><p>Educators can create AI-powered tutoring systems that reference open-source projects:</p><p>“Our programming course uses <a href="http://gitmcp.io/django/django">gitmcp.io/django/django</a> to help students understand web framework concepts through an AI assistant.”</p><h3>Privacy and Security Considerations</h3><p>GitMCP maintains a strong commitment to privacy. The service:</p><ul><li>Doesn’t require authentication, eliminating the need to store personal information</li><li>Doesn’t store queries sent by AI agents</li><li>Only accesses publicly available content</li><li>Respects robots.txt directives for GitHub Pages sites</li><li>Doesn’t permanently store data about GitHub projects</li></ul><p>For organizations with heightened security requirements, GitMCP’s open-source nature allows for self-hosting, providing complete control over the implementation.</p><h3>Optimizing Your Repository for GitMCP</h3><p>While GitMCP works with any GitHub repository without configuration, you can enhance the experience by:</p><h3>Creating an llms.txt File</h3><p>This file serves as dedicated documentation for AI assistants. It can include:</p><ul><li>Project overview and purpose</li><li>Key concepts and terminology</li><li>Common use cases and examples</li><li>Frequently asked questions</li><li>Links to additional resources</li></ul><h3>Organizing Documentation</h3><p>Well-structured documentation with clear headings, concise descriptions, and relevant examples improves semantic search results and overall AI comprehension.</p><h3>Including Code Samples</h3><p>Annotated code examples help AI assistants provide accurate implementation guidance.</p><h3>Technical Implementation Details</h3><p>GitMCP is built with TypeScript and leverages Cloudflare Workers for serverless deployment. The system uses vector embeddings to enable semantic search capabilities and implements the Model Context Protocol specification for standardized communication with AI assistants.</p><p>The open-source nature of GitMCP encourages community contributions and customizations. Organizations can fork the repository to implement additional features or modify the service for specific use cases.</p><h3>Benefits for Open-Source Communities</h3><p>GitMCP significantly enhances open-source project accessibility by:</p><ol><li>Reducing the learning curve for new contributors</li><li>Promoting documentation best practices</li><li>Increasing project discoverability through AI assistant recommendations</li><li>Enabling more effective knowledge sharing</li></ol><h3>Conclusion</h3><p>GitMCP represents a significant step forward in making open-source knowledge more accessible to AI assistants. By implementing the Model Context Protocol for GitHub repositories, it creates a standardized interface through which AI systems can intelligently access, search, and interpret project documentation.</p><p>The service’s zero-configuration approach makes it immediately useful for any public GitHub repository. Whether you’re a developer seeking better AI assistance, a project maintainer looking to improve documentation accessibility, or an AI researcher exploring new knowledge retrieval methods, GitMCP offers valuable capabilities with minimal overhead.</p><p>As AI assistants continue to evolve, tools like GitMCP that bridge the gap between structured knowledge bases and AI systems will play an increasingly important role in making technical information more accessible and actionable.</p><p>Let’s talk about something that we all face during development: API Testing with Postman for your Development Team.</p><p>Yeah, I’ve heard of it as well, <a href="https://www.reddit.com/r/webdev/comments/kl45qq/what_the_hell_happened_to_postman/">Postman is getting worse</a> year by year, but, you are working as a team and you need some collaboration tools for your development process, right? So you paid Postman Enterprise for…. $49/month.</p><p>Now I am telling you: You Don’t Have to:</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/0*0x37K1r5epLnGsrT.png" /></figure><p>That’s right, APIDog gives you all the features that comes with Postman paid version, at a fraction of the cost. Migration has been so easily that you only need to click a few buttons, and APIDog will do everything for you.</p><p><a href="https://bit.ly/3TdVn6U">How to Migrate Postman Collections/Environments to Apidog</a></p><p><strong>APIDog</strong> has a comprehensive, easy to use GUI that makes you spend no time to get started working (If you have migrated from Postman). It’s elegant, collaborate, easy to use, with Dark Mode too!</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/0*6PZT6kIK6G9pTNdg.png" /></figure><p>Want a Good Alternative to Postman? APIDog is definitely worth a shot. But if you are the Tech Lead of a Dev Team that really want to dump Postman for something Better, and Cheaper, Check out APIDog!</p><p><a href="https://bit.ly/4ebMDGm">Apidog: All-in-One API Platform: Design, Debug, Mock, Test, and Document</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=91da5ac554d0" width="1" height="1" alt=""><hr><p><a href="https://medium.com/towards-agi/gitmcp-transforming-github-repositories-into-ai-accessible-knowledge-bases-91da5ac554d0">GitMCP: Turn Any Github Repo into MCP Servers</a> was originally published in <a href="https://medium.com/towards-agi">Towards AGI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What is Agent2Agent and Why You Must Learn It Now]]></title>
            <link>https://medium.com/towards-agi/what-is-agent2agent-and-why-you-must-learn-it-now-5e5a00f16005?source=rss-d1e94386bbd1------2</link>
            <guid isPermaLink="false">https://medium.com/p/5e5a00f16005</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Asaki Sakamoto]]></dc:creator>
            <pubDate>Fri, 11 Apr 2025 05:51:04 GMT</pubDate>
            <atom:updated>2025-04-11T05:51:22.130Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*X9frXwHBP4ouvBKf.jpg" /></figure><p>In the rapidly evolving landscape of artificial intelligence, a groundbreaking development has emerged that promises to fundamentally transform how AI systems interact and collaborate: the Agent2Agent Protocol, or A2A. This open protocol, recently announced by Google Cloud in collaboration with over 50 technology partners, represents a paradigm shift in AI architecture and sets the foundation for a new era of interoperable, collaborative AI agents. For professionals across industries, understanding A2A is no longer optional but essential for staying competitive in the AI-driven future.</p><p>Let’s talk about something that we all face during development: API Testing with Postman for your Development Team.</p><p>Yeah, I’ve heard of it as well, <a href="https://www.reddit.com/r/webdev/comments/kl45qq/what_the_hell_happened_to_postman/">Postman is getting worse</a> year by year, but, you are working as a team and you need some collaboration tools for your development process, right? So you paid Postman Enterprise for…. $49/month.</p><p>Now I am telling you: You Don’t Have to:</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/0*0x37K1r5epLnGsrT.png" /></figure><p>That’s right, APIDog gives you all the features that comes with Postman paid version, at a fraction of the cost. Migration has been so easily that you only need to click a few buttons, and APIDog will do everything for you.</p><p><a href="https://bit.ly/3TdVn6U">How to Migrate Postman Collections/Environments to Apidog</a></p><p><strong>APIDog</strong> has a comprehensive, easy to use GUI that makes you spend no time to get started working (If you have migrated from Postman). It’s elegant, collaborate, easy to use, with Dark Mode too!</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/0*6PZT6kIK6G9pTNdg.png" /></figure><p>Want a Good Alternative to Postman? APIDog is definitely worth a shot. But if you are the Tech Lead of a Dev Team that really want to dump Postman for something Better, and Cheaper, Check out APIDog!</p><p><a href="https://bit.ly/4ebMDGm">Apidog: All-in-One API Platform: Design, Debug, Mock, Test, and Document</a></p><h3>The Technical Foundation of Agent2Agent (A2A)</h3><p>At its core, A2A is an open protocol that enables seamless communication and collaboration between AI agents, regardless of their underlying frameworks or vendors. The protocol creates a standardized way for AI agents to discover each other’s capabilities, exchange information securely, and coordinate complex actions across various enterprise platforms and applications.</p><h3>A2A Architecture and Core Components</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*z7upMRutXtLruHr8.png" /></figure><p>A2A is built on HTTP and JSON-RPC style interfaces, making it compatible with existing IT infrastructure. The protocol consists of several key architectural components:</p><ol><li>Agent Card: Located at /.well-known/agent.json, this is a JSON-formatted metadata file that describes an agent&#39;s capabilities, skills, endpoint URL, and authentication requirements. Clients use this for discovery and to understand what an agent can do before interacting with it.</li><li>A2A Server: This is an agent exposing an HTTP endpoint that implements the A2A protocol methods defined in the JSON specification. It receives requests and manages task execution.</li><li>A2A Client: This can be an application or another agent that consumes A2A services. It sends requests to an A2A Server’s URL using methods like tasks/send.</li><li>Task: The central unit of work in A2A. A client initiates a task by sending a message, and tasks have unique IDs that progress through defined states:</li></ol><ul><li>submitted: The initial state when a task is created</li><li>working: The agent is actively processing the task</li><li>input-required: The agent needs additional information to proceed</li><li>completed: The task has been successfully completed</li><li>failed: The task could not be completed</li><li>canceled: The task was canceled before completion</li></ul><ol><li>Message: Represents communication turns between the client (role: &quot;user&quot;) and the agent (role: &quot;agent&quot;). Messages contain Parts, which are the fundamental content units.</li><li>Part: The fundamental content unit within a Message or Artifact. It can be one of several types:</li></ol><ul><li>TextPart: For plain text content</li><li>FilePart: For binary data, with inline bytes or a URI</li><li>DataPart: For structured JSON data (e.g., forms)</li></ul><ol><li>Artifact: Represents outputs generated by the agent during a task, such as generated files or final structured data. Artifacts also contain Parts.</li></ol><h3>Communication Mechanisms in A2A</h3><p>A2A supports multiple communication patterns to accommodate different interaction requirements:</p><ol><li>Basic Request-Response: For simple interactions, clients can make HTTP requests to the server’s endpoints and receive responses synchronously.</li><li>Streaming: For long-running tasks, servers supporting the streaming capability can use tasks/sendSubscribe. The client receives Server-Sent Events (SSE) containing TaskStatusUpdateEvent or TaskArtifactUpdateEvent messages, providing real-time progress updates.</li><li>Push Notifications: Servers supporting pushNotifications can proactively send task updates to a client-provided webhook URL, configured via tasks/pushNotification/set.</li><li>User Experience Negotiation: A uniquely powerful feature of A2A is its ability to negotiate the user experience format. Agents can communicate about what UI capabilities are available (text, forms, audio/video, iframes) and adapt their interactions accordingly.</li></ol><h3>The A2A Interaction Flow</h3><p>A typical A2A interaction follows this sequence:</p><ol><li>Discovery: The client fetches the Agent Card from the server’s well-known URL to understand its capabilities.</li><li>Initiation: The client sends a tasks/send or tasks/sendSubscribe request containing the initial user message and a unique Task ID.</li><li>Processing:</li></ol><ul><li>If streaming, the server sends SSE events (status updates, artifacts) as the task progresses.</li><li>If non-streaming, the server processes the task synchronously and returns the final Task object in the response.</li></ul><ol><li>Interaction (Optional): If the task enters the input-required state, the client sends subsequent messages using the same Task ID.</li><li>Completion: The task eventually reaches a terminal state (completed, failed, or canceled).</li></ol><h3>A2A Design Principles: Technical Excellence for Enterprise Applications</h3><p>The A2A protocol was designed with five key principles that reflect its enterprise-focused architecture:</p><h3>1. Embracing Agentic Capabilities</h3><p>Unlike simple API frameworks, A2A focuses on enabling agents to collaborate in their natural, unstructured modalities, even when they don’t share memory, tools, or context. This creates true multi-agent scenarios without limiting an agent to a “tool” role. The protocol supports rich, dialogue-based interactions that reflect the autonomous nature of modern AI agents.</p><h3>2. Building on Existing Standards</h3><p>A2A is built on top of existing, popular standards including HTTP, SSE, and JSON-RPC. This architectural choice means the protocol integrates seamlessly with existing IT infrastructure that businesses use daily. This reduces implementation friction and accelerates adoption.</p><h3>3. Security by Default</h3><p>Recognizing the importance of security in enterprise environments, A2A is designed with enterprise-grade authentication and authorization from the ground up. It maintains parity with OpenAPI’s authentication schemes at launch, ensuring that agent interactions remain secure and comply with organizational security policies.</p><h3>4. Support for Long-Running Tasks</h3><p>Unlike traditional API calls that expect immediate responses, A2A is designed to support scenarios where tasks may take minutes, hours, or even days to complete, especially when humans are in the loop. Throughout these extended processes, A2A provides real-time feedback, notifications, and state updates to users and other agents.</p><h3>5. Modality Agnosticism</h3><p>Recognizing that AI communication extends beyond text, A2A is designed to be modality-agnostic, supporting various forms of content including audio and video streaming. This flexibility enables rich, multimodal agent interactions that better reflect human communication patterns.</p><h3>A2A vs. MCP: Complementary Protocols in the AI Ecosystem</h3><p>An important technical distinction is how A2A relates to Anthropic’s Model Context Protocol (MCP). These protocols serve different but complementary functions:</p><p>Model Context Protocol (MCP) focuses on how a single agent uses tools and accesses external context, providing a consistent interface for AI models to call APIs and retrieve information from databases.</p><p>Agent2Agent Protocol (A2A) focuses on dialogue and collaboration between multiple independent agents, allowing them to work together on complex tasks.</p><p>Google metaphorically explains this relationship: “If MCP is a wrench that enables agents to use tools, then A2A is the dialogue between mechanics, allowing multiple agents to communicate like a team diagnosing problems.”</p><p>Together, these protocols strengthen the autonomous agent ecosystem — MCP empowers individual agents to connect with external tools and data, while A2A connects multiple independent agents into a collaborative network.</p><h3>Technical Implementation: Building A2A-Compliant Agents</h3><p>Implementing A2A in your applications involves several key steps:</p><h3>1. Agent Card Creation</h3><p>The first step is creating an Agent Card, a JSON document that describes your agent’s capabilities and endpoints. The Agent Card typically includes:</p><pre>{<br>  &quot;name&quot;: &quot;Your Agent Name&quot;,<br>  &quot;description&quot;: &quot;A detailed description of what your agent does&quot;,<br>  &quot;version&quot;: &quot;1.0.0&quot;,<br>  &quot;endpoint&quot;: &quot;https://your-agent-endpoint.com/a2a&quot;,<br>  &quot;capabilities&quot;: {<br>    &quot;streaming&quot;: true,<br>    &quot;pushNotifications&quot;: false<br>  },<br>  &quot;authentication&quot;: {<br>    &quot;type&quot;: &quot;oauth2&quot;,<br>    &quot;flows&quot;: {<br>      &quot;clientCredentials&quot;: {<br>        &quot;tokenUrl&quot;: &quot;https://your-auth-server.com/token&quot;,<br>        &quot;scopes&quot;: {<br>          &quot;tasks&quot;: &quot;Access to create and manage tasks&quot;<br>        }<br>      }<br>    }<br>  }<br>}</pre><p>This card should be hosted at the well-known location /.well-known/agent.json for discovery.</p><h3>2. Implementing Server Methods</h3><p>Your agent needs to implement the required A2A server methods, which minimally include:</p><ul><li>tasks/send: For receiving task requests</li><li>tasks/get: For retrieving task status</li></ul><p>For streaming support, you’ll also need:</p><ul><li>tasks/sendSubscribe: For streaming task updates</li></ul><h3>3. Message and Task Handling</h3><p>Your implementation must properly handle the A2A task lifecycle, including:</p><ul><li>Generating unique task IDs</li><li>Updating task status as it progresses</li><li>Creating well-formed Messages with appropriate Parts</li><li>Producing Artifacts as outputs</li></ul><h3>4. Authentication Implementation</h3><p>For enterprise deployments, implementing robust authentication is critical. A2A supports various authentication schemes, including:</p><ul><li>OAuth 2.0</li><li>API keys</li><li>Bearer tokens</li><li>Basic authentication</li></ul><h3>5. Integration with Existing Systems</h3><p>For maximum value, A2A agents should integrate with your existing AI systems and business applications. This may involve:</p><ul><li>Connecting to LLM providers</li><li>Accessing databases and knowledge bases</li><li>Integrating with business workflow systems</li><li>Connecting to data processing pipelines</li></ul><h3>The Business Impact and Technical Advantages of A2A</h3><h3>Breaking Down Technical Silos</h3><p>In today’s enterprise environments, organizations often deploy dozens of specialized AI systems built on different frameworks and running in different environments. This fragmentation creates significant technical challenges as these systems cannot easily share information or coordinate workflows.</p><p>A2A addresses this challenge by providing a standardized communication layer that works across different AI frameworks, vendors, and environments. This eliminates the need for custom integration code between each pair of systems, dramatically reducing integration complexity and maintenance costs.</p><p>For technical teams, this means:</p><ul><li>Reduced development time for integrations</li><li>Lower maintenance burden for cross-system workflows</li><li>Greater flexibility in choosing best-of-breed AI components</li><li>Easier migration paths as technology evolves</li></ul><h3>Enabling Complex Distributed AI Architectures</h3><p>From a system architecture perspective, A2A enables the development of sophisticated distributed AI applications that were previously impractical to build and maintain. By facilitating communication between autonomous agents, A2A supports architectural patterns like:</p><ul><li>Microservice-based AI systems: Breaking complex AI workflows into specialized, independently developed and maintained agents</li><li>Federated intelligence: Distributing AI processing across organizational or departmental boundaries while maintaining secure communication</li><li>Hybrid cloud/on-premises deployments: Enabling agents running in different environments to communicate seamlessly</li><li>Cross-vendor AI solutions: Combining specialized AI capabilities from different vendors into integrated workflows</li></ul><h3>Technical Performance and Scalability</h3><p>A2A’s design includes several features that support enterprise-scale performance requirements:</p><ul><li>Stateless communication: The protocol’s stateless design improves scalability and resilience</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5e5a00f16005" width="1" height="1" alt=""><hr><p><a href="https://medium.com/towards-agi/what-is-agent2agent-and-why-you-must-learn-it-now-5e5a00f16005">What is Agent2Agent and Why You Must Learn It Now</a> was originally published in <a href="https://medium.com/towards-agi">Towards AGI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Understanding the Atlassian MCP Server: A Comprehensive Guide]]></title>
            <link>https://medium.com/towards-agi/understanding-the-atlassian-mcp-server-a-comprehensive-guide-09eed358d662?source=rss-d1e94386bbd1------2</link>
            <guid isPermaLink="false">https://medium.com/p/09eed358d662</guid>
            <category><![CDATA[mcps]]></category>
            <category><![CDATA[mcp-server]]></category>
            <category><![CDATA[atlassian]]></category>
            <dc:creator><![CDATA[Asaki Sakamoto]]></dc:creator>
            <pubDate>Wed, 09 Apr 2025 12:06:23 GMT</pubDate>
            <atom:updated>2025-04-09T12:06:23.239Z</atom:updated>
            <content:encoded><![CDATA[<p>In today’s fast-paced development environment, integrating AI tools with existing workflows has become essential for productivity. The Atlassian MCP server stands at the forefront of this innovation, offering a powerful bridge between AI models and Atlassian products like Jira and Confluence. This comprehensive guide will walk you through everything you need to know about using the Atlassian MCP server effectively.</p><p><strong>Pro Tip:</strong> Boost your AI development workflow by integrating the <a href="https://bit.ly/41ItNSS">Apidog MCP Server</a> into your IDE. This gives your AI assistant real-time access to API specifications, enabling it to generate code, refine documentation, and streamline data model creation — all while ensuring alignment with your API design. 🚀</p><ul><li><a href="https://sebastian-petrus.medium.com/apidog-mcp-server-b477c888757e">Apidog MCP Server: The Bridge Between Your API Specifications and AI Coding Assistants</a></li><li><a href="https://www.npmjs.com/package/apidog-mcp-server">apidog-mcp-server</a></li></ul><h3>What is an Atlassian MCP Server?</h3><p>The Atlassian MCP server is an implementation of the Model Context Protocol (MCP) designed specifically for Atlassian products. MCP, developed by Anthropic, provides a standardized framework for AI models to interact with external systems. This server enables AI assistants like Claude to connect directly with Confluence and Jira, allowing users to perform tasks, search for content, and manipulate data using natural language commands.</p><p>The beauty of the Atlassian MCP server lies in its ability to translate between AI systems and Atlassian’s APIs, creating a seamless experience where users can manage their Atlassian ecosystem through conversational interfaces. This integration supports both cloud-based and self-hosted (Server/Data Center) deployments of Confluence and Jira.</p><h3>Benefits of Implementing Atlassian MCP Server</h3><p>Implementing an Atlassian MCP server brings numerous advantages to organizations that rely on Jira and Confluence:</p><ol><li>Enhanced Productivity: Perform complex searches and actions through simple natural language commands</li><li>Reduced Context Switching: Access information without leaving your AI assistant interface</li><li>Streamlined Workflows: Automate repetitive tasks across Atlassian products</li><li>Improved Accessibility: Make Atlassian tools more accessible to team members who prefer conversational interfaces</li><li>Knowledge Integration: Connect your AI assistant directly with your organization’s knowledge base</li></ol><p>Teams that effectively implement the Atlassian MCP server often report significant time savings and improved collaboration across departments.</p><h3>Setting Up Your Atlassian MCP Server: Prerequisites</h3><p>Before diving into the Atlassian MCP server setup, ensure you have the following prerequisites in place:</p><ol><li>Python Environment: Python 3.9 or higher installed on your system</li><li>Atlassian Access: Valid credentials for your Confluence and/or Jira instances</li><li>Package Manager: A package manager like uv (recommended) or pip</li><li>MCP-Compatible AI Tool: An AI assistant that supports MCP, such as Claude Desktop or Cursor IDE</li><li>Basic Command Line Knowledge: Familiarity with running commands in a terminal</li></ol><p>Having these elements ready will ensure a smooth installation process as you set up your Atlassian MCP server.</p><h3>Authentication Setup for Atlassian MCP Server</h3><p>Authentication is a critical step when configuring your Atlassian MCP server. The approach differs slightly depending on whether you’re using Cloud or Server/Data Center deployments:</p><h3>For Atlassian Cloud:</h3><ol><li>Navigate to <a href="https://id.atlassian.com/manage-profile/security/api-tokens">https://id.atlassian.com/manage-profile/security/api-tokens</a></li><li>Click “Create API token” and give it a descriptive name</li><li>Copy the token immediately (it will only be shown once)</li><li>Keep this token secure for configuration</li></ol><h3>For Server/Data Center:</h3><ol><li>Go to your profile by clicking your avatar</li><li>Navigate to “Profile” → “Personal Access Tokens”</li><li>Create a token with appropriate permissions</li><li>Copy the token for your configuration</li></ol><p>These authentication tokens will serve as the security credentials allowing your Atlassian MCP server to communicate with your Atlassian instances.</p><h3>Installation Methods for Atlassian MCP Server</h3><p>The Atlassian MCP server offers several installation options to suit different environments and preferences:</p><h3>Using uv (Recommended):</h3><pre>brew install uv uvx mcp-atlassian</pre><h3>Using pip:</h3><pre>pip install mcp-atlassian</pre><h3>From Source:</h3><pre>git clone https://github.com/sooperset/mcp-atlassian.git<br>cd mcp-atlassian</pre><h3>Using Docker:</h3><pre>docker build -t mcp/atlassian .</pre><p>Choose the method that best aligns with your technical environment and expertise.</p><h3>Configuring Your Atlassian MCP Server</h3><p>Once installed, you’ll need to configure your Atlassian MCP server with the appropriate connection details:</p><h3>For Confluence and Jira Cloud:</h3><pre>uvx mcp-atlassian \<br>  --confluence-url https://your-company.atlassian.net/wiki \<br>  --confluence-username your.email@company.com \<br>  --confluence-token your_api_token \<br>  --jira-url https://your-company.atlassian.net \<br>  --jira-username your.email@company.com \<br>  --jira-token your_api_token</pre><h3>For Server/Data Center:</h3><pre>uvx mcp-atlassian \<br>  --confluence-url https://confluence.your-company.com \<br>  --confluence-personal-token your_token \<br>  --jira-url https://jira.your-company.com \<br>  --jira-personal-token your_token</pre><p>You can configure just Confluence, just Jira, or both services depending on your needs.</p><h3>Optional Arguments for Atlassian MCP Server</h3><p>The Atlassian MCP server supports several optional arguments to customize its behavior:</p><ul><li>--transport: Choose transport type (stdio [default] or sse)</li><li>--port: Port number for SSE transport (default: 8000)</li><li>--[no-]confluence-ssl-verify: Toggle SSL verification for Confluence</li><li>--[no-]jira-ssl-verify: Toggle SSL verification for Jira</li><li>--confluence-spaces-filter: Filter Confluence search by space keys</li><li>--jira-projects-filter: Filter Jira search by project keys</li><li>--read-only: Run in read-only mode (disables write operations)</li><li>--verbose or -v: Increase logging verbosity</li></ul><p>These options allow you to fine-tune the Atlassian MCP server to meet your specific requirements and security policies.</p><h3>Integrating Atlassian MCP Server with AI Tools</h3><p>To leverage your Atlassian MCP server, you need to integrate it with compatible AI tools:</p><h3>Claude Desktop Setup:</h3><ol><li>Edit the configuration file:</li></ol><ul><li>Mac: ~/Library/ApplicationSupport/Claude/claude_desktop_config.json</li><li>Windows: %APPDATA%\Claude\claude_desktop_config.json</li></ul><ol><li>Add your configuration:</li></ol><pre>{<br>  &quot;mcpServers&quot;: {<br>    &quot;mcp-atlassian&quot;: {<br>      &quot;command&quot;: &quot;uvx&quot;,<br>      &quot;args&quot;: [<br>        &quot;mcp-atlassian&quot;,<br>        &quot;--confluence-url=https://your-company.atlassian.net/wiki&quot;,<br>        &quot;--confluence-username=your.email@company.com&quot;,<br>        &quot;--confluence-token=your_api_token&quot;,<br>        &quot;--jira-url=https://your-company.atlassian.net&quot;,<br>        &quot;--jira-username=your.email@company.com&quot;,<br>        &quot;--jira-token=your_api_token&quot;<br>      ]<br>    }<br>  }<br>}</pre><h3>Cursor IDE Setup:</h3><ol><li>Open Settings &gt; Features &gt; MCP Servers</li><li>Add a new global MCP server with similar configuration as above</li></ol><p>After configuration, restart your AI tool to connect to the Atlassian MCP server.</p><h3>Advanced Atlassian MCP Server Configuration Options</h3><p>For more sophisticated deployments, consider these advanced configuration options:</p><h3>Using Environment Variables:</h3><p>Create a .env file with your credentials:</p><pre>CONFLUENCE_URL=https://your-company.atlassian.net/wiki<br>CONFLUENCE_USERNAME=your.email@company.com<br>CONFLUENCE_API_TOKEN=your_api_token<br>JIRA_URL=https://your-company.atlassian.net<br>JIRA_USERNAME=your.email@company.com<br>JIRA_API_TOKEN=your_api_token</pre><h3>Using SSE Transport:</h3><p>Start the server with:</p><pre>uvx mcp-atlassian --transport sse --port 9000 [other config options]</pre><p>Then configure your AI tool with just the URL:</p><pre>{<br>  &quot;mcpServers&quot;: {<br>    &quot;mcp-atlassian-sse&quot;: {<br>      &quot;url&quot;: &quot;http://localhost:9000/sse&quot;<br>    }<br>  }<br>}</pre><p>These advanced options provide flexibility for various deployment scenarios.</p><h3>Tools Available in the Atlassian MCP Server</h3><p>The Atlassian MCP server provides numerous tools for interacting with your Atlassian products:</p><h3>Confluence Tools:</h3><ul><li>confluence_search: Search Confluence content using CQL</li><li>confluence_get_page: Retrieve specific page content</li><li>confluence_get_page_children: Get child pages</li><li>confluence_create_page: Create new pages</li><li>confluence_update_page: Update existing pages</li><li>confluence_delete_page: Delete pages</li><li>confluence_attach_content: Attach files to pages</li></ul><h3>Jira Tools:</h3><ul><li>jira_search: Search issues using JQL</li><li>jira_get_issue: Get detailed issue information</li><li>jira_create_issue: Create new issues</li><li>jira_update_issue: Update existing issues</li><li>jira_transition_issue: Change issue status</li><li>jira_add_comment: Add comments to issues</li><li>jira_get_worklog: Retrieve work logs</li><li>jira_add_worklog: Log work on issues</li><li>jira_get_agile_boards: Access agile boards</li><li>jira_get_sprints_from_board: Get sprint information</li></ul><p>These tools enable comprehensive interaction with your Atlassian ecosystem.</p><h3>Practical Use Cases for Atlassian MCP Server</h3><p>The Atlassian MCP server enables numerous practical applications:</p><ol><li>Knowledge Management: “Find all pages in the TECH space about AWS architecture”</li><li>Issue Tracking: “Show me all critical bugs assigned to my team”</li><li>Content Creation: “Create a new page in the DOCS space titled ‘API Documentation’”</li><li>Project Management: “Move all completed tickets to Done status”</li><li>Reporting: “Summarize the current sprint progress”</li><li>Documentation: “Update the installation guide with the new configuration steps”</li></ol><p>These use cases demonstrate how the Atlassian MCP server can transform your interaction with Confluence and Jira.</p><h3>Troubleshooting Common Atlassian MCP Server Issues</h3><p>If you encounter problems with your Atlassian MCP server:</p><ol><li>Connection Issues: Verify URLs and network access</li><li>Authentication Problems: Check credentials and token validity</li><li>Integration Errors: Review configuration in AI tools</li><li>Permission Denied: Ensure your token has appropriate permissions</li><li>Version Compatibility: Confirm compatibility with your Atlassian products</li></ol><p>For debugging, check logs with:</p><pre>tail -f /Library/Logs/Claude/mcp.log</pre><p>Or use the MCP Inspector:</p><pre>npx @modelcontextprotocol/inspector</pre><h3>Atlassian MCP Server Security Best Practices</h3><p>Maintaining security is paramount when using the Atlassian MCP server:</p><ol><li>Secure Token Storage: Never expose tokens in public repositories</li><li>Principle of Least Privilege: Use tokens with minimal necessary permissions</li><li>Read-Only Mode: Use --read-only when write access isn&#39;t needed</li><li>Regular Token Rotation: Change tokens periodically</li><li>SSL Verification: Keep SSL verification enabled in production</li></ol><p>Following these practices helps protect your Atlassian data while leveraging AI capabilities.</p><h3>Conclusion: Maximizing Value from Your Atlassian MCP Server</h3><p>The Atlassian MCP server represents a significant advancement in how teams interact with their Atlassian tools. By creating a bridge between AI assistants and your knowledge base, it enhances productivity, streamlines workflows, and makes information more accessible.</p><p>As you implement and refine your Atlassian MCP server setup, focus on building use cases that deliver the most value to your team. Start with simple queries and gradually expand to more complex workflows as users become comfortable with the integration.</p><p>With proper configuration and usage, the Atlassian MCP server can transform your team’s relationship with Confluence and Jira, creating a more intuitive, efficient, and accessible work environment powered by the latest advancements in AI technology.</p><p>Before we conclude, let’s talk about something that we all face during development: API Testing with Postman for your Development Team.</p><p>Yeah, I’ve heard of it as well, <a href="https://www.reddit.com/r/webdev/comments/kl45qq/what_the_hell_happened_to_postman/">Postman is getting worse</a> year by year, but, you are working as a team and you need some collaboration tools for your development process, right? So you paid Postman Enterprise for…. $49/month.</p><p>Now I am telling you: You Don’t Have to:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SzJh_AZ07FvJRZtxDcQySg.png" /><figcaption>APIDog: You Get Everything from Postman Paid Version, But CHEAPER</figcaption></figure><p>That’s right, APIDog gives you all the features that comes with Postman paid version, at a fraction of the cost. Migration has been so easily that you only need to click a few buttons, and APIDog will do everything for you.</p><p><a href="https://bit.ly/3FZck1e">Apidog An integrated platform for API design, debugging, development, mock, and testing</a></p><p>APIDog has a comprehensive, easy to use GUI that makes you spend no time to get started working (If you have migrated from Postman). It’s elegant, collaborate, easy to use, with Dark Mode too!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*5IU81JhalGY8F5Od.png" /><figcaption>APIDog makes you very easy to migrate from Postman with No Learning Curve</figcaption></figure><p>Want a Good Alternative to Postman? APIDog is definitely worth a shot. But if you are the Tech Lead of a Dev Team that really want to dump Postman for something Better, and Cheaper, Check out APIDog!</p><p><a href="https://bit.ly/3FZck1e">Apidog An integrated platform for API design, debugging, development, mock, and testing</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=09eed358d662" width="1" height="1" alt=""><hr><p><a href="https://medium.com/towards-agi/understanding-the-atlassian-mcp-server-a-comprehensive-guide-09eed358d662">Understanding the Atlassian MCP Server: A Comprehensive Guide</a> was originally published in <a href="https://medium.com/towards-agi">Towards AGI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Use Solana Agent MCP Server: A Comprehensive Guide]]></title>
            <link>https://medium.com/towards-agi/how-to-use-solana-agent-mcp-server-a-comprehensive-guide-83fd3263571c?source=rss-d1e94386bbd1------2</link>
            <guid isPermaLink="false">https://medium.com/p/83fd3263571c</guid>
            <category><![CDATA[mcps]]></category>
            <category><![CDATA[solanas]]></category>
            <category><![CDATA[mcp-server]]></category>
            <dc:creator><![CDATA[Asaki Sakamoto]]></dc:creator>
            <pubDate>Wed, 09 Apr 2025 12:06:21 GMT</pubDate>
            <atom:updated>2025-04-09T12:06:21.140Z</atom:updated>
            <content:encoded><![CDATA[<h3>Understanding the Solana Agent MCP Server Basics</h3><p>The Solana Agent MCP Server represents a groundbreaking integration between artificial intelligence and blockchain technology. This Model Context Protocol (MCP) server enables AI models like Claude and other LLM-based assistants to interact directly with the Solana blockchain. By implementing the Solana Agent MCP Server, developers can create AI agents capable of performing over 40 different blockchain actions without requiring extensive manual coding or intervention.</p><p>The primary advantage of the Solana Agent MCP Server is that it bridges the gap between conversational AI interfaces and Solana&#39;s high-performance blockchain. This means users can instruct their AI assistants to perform complex operations like deploying NFT collections, trading tokens, or checking wallet balances using natural language commands rather than technical blockchain interactions.</p><p><strong>Pro Tip:</strong> Boost your AI development workflow by integrating the <a href="https://bit.ly/41ItNSS">Apidog MCP Server</a> into your IDE. This gives your AI assistant real-time access to API specifications, enabling it to generate code, refine documentation, and streamline data model creation — all while ensuring alignment with your API design. 🚀</p><ul><li><a href="https://sebastian-petrus.medium.com/apidog-mcp-server-b477c888757e">Apidog MCP Server: The Bridge Between Your API Specifications and AI Coding Assistants</a></li><li><a href="https://www.npmjs.com/package/apidog-mcp-server">apidog-mcp-server</a></li></ul><h3>Setting Up Your Solana Agent MCP Server Environment</h3><p>Before diving into the Solana Agent MCP Server functionality, you&#39;ll need to set up your development environment properly. The setup process requires several key components:</p><ol><li>Node.js: Ensure you have the latest stable version installed on your machine.</li><li>Solana CLI: Install the Solana Command Line Interface tools for local testing.</li><li>RPC Endpoint: Access to a Solana blockchain node (either mainnet-beta, testnet, or devnet).</li><li>Private Key: A Solana wallet private key for transactions (use a development wallet for testing).</li><li>OpenAI API Key: Required for natural language processing capabilities.</li></ol><p>To install the Solana Agent MCP Server, run the following command in your terminal:</p><pre>npm install solana-agent-kit @modelcontextprotocol/server-core</pre><p>For those using the Claude Desktop application or other MCP-compatible clients, you&#39;ll need to add the server to your configuration:</p><pre>{<br>  &quot;mcpServers&quot;: {<br>    &quot;solana&quot;: {<br>      &quot;command&quot;: &quot;npx&quot;,<br>      &quot;args&quot;: [&quot;-y&quot;, &quot;solana-agent-kit&quot;]<br>    }<br>  }<br>}</pre><h3>Configuring Your Solana Agent MCP Server Connection</h3><p>Proper configuration of the Solana Agent MCP Server is essential for secure and reliable operation. The server requires specific environment variables to function:</p><ol><li>SOLANA_PRIVATE_KEY: Your wallet&#39;s private key (in base58 format)</li><li>SOLANA_RPC_URL: The RPC endpoint URL</li><li>OPENAI_API_KEY: Your OpenAI API key for NLP capabilities</li></ol><p>For security reasons, it&#39;s recommended to store these in a .env file and use a package like dotenv to load them:</p><pre>import * as dotenv from &#39;dotenv&#39;;<br>import { SolanaAgentKit } from &#39;solana-agent-kit&#39;;<br><br>dotenv.config();<br><br>const solanaKit = new SolanaAgentKit(<br>  process.env.SOLANA_PRIVATE_KEY,<br>  process.env.SOLANA_RPC_URL,<br>  process.env.OPENAI_API_KEY<br>);</pre><p>When configuring for production environments, implement additional security measures such as key encryption and access controls to protect sensitive wallet information.</p><h3>Core Features of the Solana Agent MCP Server</h3><p>The Solana Agent MCP Server provides an extensive suite of blockchain interaction capabilities. These features are exposed as tools that AI assistants can leverage through the Model Context Protocol:</p><h3>Token Management</h3><ul><li>Check wallet balances</li><li>Transfer SPL tokens or SOL</li><li>Create new tokens</li><li>Mint tokens to wallets</li></ul><h3>NFT Operations</h3><ul><li>Deploy NFT collections</li><li>Mint NFTs</li><li>List NFTs on marketplaces</li><li>Check NFT metadata</li></ul><h3>DeFi Integrations</h3><ul><li>Swap tokens on decentralized exchanges</li><li>Provide liquidity in pools</li><li>Stake tokens for yield</li><li>Borrow and lend assets</li></ul><h3>Network Information</h3><ul><li>Check transaction status</li><li>Retrieve block information</li><li>Monitor network stats</li><li>Query program data</li></ul><p>Each of these features is accessible through standardized tool interfaces that follow the MCP specification, making them easily invokable by compatible AI models.</p><h3>Implementing Solana Agent MCP Server in Your Applications</h3><p>Implementing the Solana Agent MCP Server in your application involves a few key steps:</p><ol><li>Initialize the server: Create an instance of the SolanaAgentKit with your credentials.</li></ol><pre>import { createMCPServer } from &#39;@modelcontextprotocol/server-core&#39;;<br>import { SolanaAgentKit } from &#39;solana-agent-kit&#39;;<br><br>const solanaKit = new SolanaAgentKit(<br>  process.env.SOLANA_PRIVATE_KEY,<br>  process.env.SOLANA_RPC_URL,<br>  process.env.OPENAI_API_KEY<br>);<br><br>const server = createMCPServer({<br>  tools: solanaKit.getTools(),<br>  resources: solanaKit.getResources()<br>});<br><br>server.start();</pre><ol><li>Define schemas: Use libraries like Zod to validate input parameters before executing blockchain transactions:</li></ol><pre>import { z } from &quot;zod&quot;;<br><br>const tokenTransferSchema = z.object({<br>  recipientAddress: z.string(),<br>  amount: z.number().positive(),<br>  tokenMint: z.string().optional(), // SOL is default<br>});</pre><ol><li>Execute transactions: Use the toolkit methods to perform blockchain operations:</li></ol><pre>async function transferTokens(params) {<br>  try {<br>    const validatedParams = tokenTransferSchema.parse(params);<br>    const result = await solanaKit.transferTokens(validatedParams);<br>    return {<br>      success: true,<br>      signature: result.signature,<br>      message: &quot;Transfer completed successfully&quot;<br>    };<br>  } catch (error) {<br>    return {<br>      success: false,<br>      error: error.message<br>    };<br>  }<br>}</pre><h3>Advanced Usage of Solana Agent MCP Server with AI Systems</h3><p>The true power of the Solana Agent MCP Server emerges when integrated with AI systems. Here are advanced use cases:</p><h3>Goal-Oriented Blockchain Tasks</h3><p>When implementing with frameworks like ElizaOS, you can create goal-oriented agents that execute complex multi-step blockchain operations:</p><pre>const deployNFTGoal = {<br>  name: &quot;Deploy NFT Collection&quot;,<br>  objectives: [<br>    { id: &quot;gather_params&quot;, description: &quot;Gather collection parameters&quot; },<br>    { id: &quot;validate_inputs&quot;, description: &quot;Validate user inputs&quot; },<br>    { id: &quot;deploy_collection&quot;, description: &quot;Deploy the collection&quot; },<br>    { id: &quot;notify_user&quot;, description: &quot;Notify user of success&quot; }<br>  ]<br>};</pre><h3>Multi-Agent Orchestration</h3><p>You can orchestrate multiple specialized agents, each handling different aspects of blockchain operations:</p><ol><li>Analyst Agent: Evaluates market data before trading</li><li>Trade Execution Agent: Performs the actual swaps</li><li>Risk Management Agent: Monitors positions and sets stop-losses</li><li>Reporting Agent: Generates transaction summaries</li></ol><h3>Custom Tool Development</h3><p>Extend the Solana Agent MCP Server with custom tools for specific projects:</p><p>Before we conclude, let’s talk about something that we all face during development: API Testing with Postman for your Development Team.</p><p>Yeah, I’ve heard of it as well, <a href="https://www.reddit.com/r/webdev/comments/kl45qq/what_the_hell_happened_to_postman/">Postman is getting worse</a> year by year, but, you are working as a team and you need some collaboration tools for your development process, right? So you paid Postman Enterprise for…. $49/month.</p><p>Now I am telling you: You Don’t Have to:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SzJh_AZ07FvJRZtxDcQySg.png" /><figcaption>APIDog: You Get Everything from Postman Paid Version, But CHEAPER</figcaption></figure><p>That’s right, APIDog gives you all the features that comes with Postman paid version, at a fraction of the cost. Migration has been so easily that you only need to click a few buttons, and APIDog will do everything for you.</p><p><a href="https://bit.ly/3FZck1e">Apidog An integrated platform for API design, debugging, development, mock, and testing</a></p><p>APIDog has a comprehensive, easy to use GUI that makes you spend no time to get started working (If you have migrated from Postman). It’s elegant, collaborate, easy to use, with Dark Mode too!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*5IU81JhalGY8F5Od.png" /><figcaption>APIDog makes you very easy to migrate from Postman with No Learning Curve</figcaption></figure><p>Want a Good Alternative to Postman? APIDog is definitely worth a shot. But if you are the Tech Lead of a Dev Team that really want to dump Postman for something Better, and Cheaper, Check out APIDog!</p><p><a href="https://bit.ly/3FZck1e">Apidog An integrated platform for API design, debugging, development, mock, and testing</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=83fd3263571c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/towards-agi/how-to-use-solana-agent-mcp-server-a-comprehensive-guide-83fd3263571c">How to Use Solana Agent MCP Server: A Comprehensive Guide</a> was originally published in <a href="https://medium.com/towards-agi">Towards AGI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Getting Started with Obsidian MCP Server: A Comprehensive Guide]]></title>
            <link>https://medium.com/towards-agi/getting-started-with-obsidian-mcp-server-a-comprehensive-guide-6f44ba3fb279?source=rss-d1e94386bbd1------2</link>
            <guid isPermaLink="false">https://medium.com/p/6f44ba3fb279</guid>
            <category><![CDATA[mcp-server]]></category>
            <category><![CDATA[obsidian]]></category>
            <category><![CDATA[mcps]]></category>
            <dc:creator><![CDATA[Asaki Sakamoto]]></dc:creator>
            <pubDate>Wed, 09 Apr 2025 12:06:19 GMT</pubDate>
            <atom:updated>2025-04-09T12:06:19.217Z</atom:updated>
            <content:encoded><![CDATA[<p>In the evolving landscape of AI-powered tools for knowledge management, the Obsidian MCP Server stands out as a powerful bridge between large language models and your personal knowledge base. This comprehensive guide will walk you through everything you need to know about setting up and leveraging an Obsidian MCP Server to enhance your note-taking and knowledge management workflow.</p><p><strong>Pro Tip:</strong> Boost your AI development workflow by integrating the <a href="https://bit.ly/41ItNSS">Apidog MCP Server</a> into your IDE. This gives your AI assistant real-time access to API specifications, enabling it to generate code, refine documentation, and streamline data model creation — all while ensuring alignment with your API design. 🚀</p><ul><li><a href="https://sebastian-petrus.medium.com/apidog-mcp-server-b477c888757e">Apidog MCP Server: The Bridge Between Your API Specifications and AI Coding Assistants</a></li><li><a href="https://www.npmjs.com/package/apidog-mcp-server">apidog-mcp-server</a></li></ul><h3>What is an Obsidian MCP Server?</h3><p>The Obsidian MCP Server is a specialized implementation of Anthropic&#39;s Model Context Protocol (MCP) designed specifically to interact with Obsidian vaults. MCP serves as a standardized interface allowing AI models like Claude to access external tools and resources securely. In the case of an Obsidian MCP Server, it enables AI assistants to read from, search within, and write to your Obsidian vault, creating a seamless integration between your knowledge base and AI capabilities.</p><p>This server acts as the middleware that handles communication between the AI model and your Obsidian vault, implementing various tools that allow for file operations, complex searches, and property management. Built with TypeScript, it emphasizes security, performance, and intuitive interaction with your notes.</p><h3>Why You Should Consider an Obsidian MCP Server</h3><p>Before diving into the setup process, it&#39;s important to understand the benefits of implementing an Obsidian MCP Server:</p><ol><li>Direct AI access to your knowledge base: AI assistants can read and reference your existing notes</li><li>Automated note-taking: Create, update, and organize notes through AI interactions</li><li>Enhanced search capabilities: Leverage AI to find connections across your entire vault</li><li>Metadata management: Intelligently update tags, properties, and frontmatter</li><li>Workflow automation: Combine AI reasoning with structured knowledge management</li></ol><h3>Prerequisites for Setting Up an Obsidian MCP Server</h3><p>To get started with an Obsidian MCP Server, you&#39;ll need:</p><ol><li>Node.js installed on your system</li><li>Obsidian with the Local REST API plugin enabled</li><li>Claude Desktop or another MCP-compatible AI client</li><li>Basic knowledge of terminal commands and JSON configuration</li></ol><h3>Installing the Obsidian MCP Server</h3><p>There are two primary methods to install the Obsidian MCP Server:</p><h3>Method 1: Install from GitHub (Recommended for Customization)</h3><ol><li>Open your terminal or command prompt</li><li>Clone the repository:</li></ol><ul><li>git clone git@github.com:cyanheads/obsidian-mcp-server.git</li></ul><ol><li>Navigate to the directory:</li></ol><ul><li>cd obsidian-mcp-server</li></ul><ol><li>Install dependencies:</li></ol><ul><li>npm install</li></ul><ol><li>Build the server:</li></ol><ul><li>npm run build</li></ul><h3>Method 2: Install via NPM (Simpler Approach)</h3><p>If you prefer a more straightforward installation, you can simply use npm:</p><pre>npm install obsidian-mcp-server</pre><h3>Configuring Your Obsidian MCP Server</h3><p>Proper configuration is crucial for the secure and efficient operation of your Obsidian MCP Server. Here are the essential configuration steps:</p><h3>Step 1: Enable Local REST API in Obsidian</h3><ol><li>Open Obsidian and go to Settings</li><li>Navigate to Community Plugins</li><li>Search for &quot;Local REST API&quot; and install it</li><li>Enable the plugin</li><li>Generate an API key through the plugin&#39;s settings</li><li>Note the port number (default is 27124)</li></ol><h3>Step 2: Create MCP Client Configuration</h3><p>You&#39;ll need to add the Obsidian MCP Server to your MCP client settings. Create or edit a configuration file (such as claude_desktop_config.json or cline_mcp_settings.json) with the following structure:</p><pre>{<br>  &quot;mcpServers&quot;: {<br>    &quot;obsidian-mcp-server&quot;: {<br>      &quot;command&quot;: &quot;node&quot;,<br>      &quot;args&quot;: [&quot;/path/to/obsidian-mcp-server/build/index.js&quot;],<br>      &quot;env&quot;: {<br>        &quot;OBSIDIAN_API_KEY&quot;: &quot;your_api_key_here&quot;,<br>        &quot;VERIFY_SSL&quot;: false,<br>        &quot;OBSIDIAN_PROTOCOL&quot;: &quot;https&quot;,<br>        &quot;OBSIDIAN_HOST&quot;: &quot;127.0.0.1&quot;,<br>        &quot;OBSIDIAN_PORT&quot;: 27124,<br>        &quot;REQUEST_TIMEOUT&quot;: 5000,<br>        &quot;MAX_CONTENT_LENGTH&quot;: 52428800,<br>        &quot;MAX_BODY_LENGTH&quot;: 52428800,<br>        &quot;RATE_LIMIT_WINDOW_MS&quot;: 900000,<br>        &quot;RATE_LIMIT_MAX_REQUESTS&quot;: 200,<br>        &quot;TOOL_TIMEOUT_MS&quot;: 60000<br>      }<br>    }<br>  }<br>}</pre><p>Ensure you replace /path/to/obsidian-mcp-server/build/index.js with the actual path and your_api_key_here with the API key generated in Obsidian.</p><h3>Step 3: Understanding Environment Variables</h3><p>The Obsidian MCP Server&#39;s behavior can be fine-tuned through various environment variables:</p><ul><li>Required Variables:</li><li>OBSIDIAN_API_KEY: Your API key from the Local REST API plugin</li><li>Connection Settings:</li><li>VERIFY_SSL: Set to false for self-signed certificates (default for local use)</li><li>OBSIDIAN_PROTOCOL: Protocol to use (default: &quot;https&quot;)</li><li>OBSIDIAN_HOST: Host address (default: &quot;127.0.0.1&quot;)</li><li>OBSIDIAN_PORT: Port number (default: 27124)</li><li>Request Limits:</li><li>REQUEST_TIMEOUT: Request timeout in milliseconds (default: 5000)</li><li>MAX_CONTENT_LENGTH: Maximum response content length (default: 50MB)</li><li>MAX_BODY_LENGTH: Maximum request body length (default: 50MB)</li><li>Rate Limiting:</li><li>RATE_LIMIT_WINDOW_MS: Rate limit window (default: 15 minutes)</li><li>RATE_LIMIT_MAX_REQUESTS: Maximum requests per window (default: 200)</li></ul><h3>Using the Obsidian MCP Server Tools</h3><p>The Obsidian MCP Server provides several powerful tools for interacting with your vault. Here&#39;s how to leverage them effectively:</p><h3>File Management Tools in Obsidian MCP Server</h3><p>The server offers three primary file management tools:</p><ol><li>obsidian_list_files_in_vault: Lists all files in your vault</li><li>obsidian_list_files_in_dir: Lists files in a specific directory</li><li>obsidian_get_file_contents: Retrieves the contents of a specific file</li></ol><p>Example usage through your AI assistant:<br>&quot;Please list all files in my vault&quot; or &quot;Show me the contents of my &#39;Project Ideas.md&#39; file&quot;</p><h3>Search Capabilities of Obsidian MCP Server</h3><p>The search tools provide powerful ways to find information across your vault:</p><ol><li>obsidian_find_in_file: Performs text searches with configurable context</li><li>obsidian_complex_search: Enables advanced searches using JsonLogic queries</li><li>obsidian_get_tags: Retrieves all tags used in your vault or a specific directory</li></ol><p>Example usage:<br>&quot;Find all notes containing the keyword &#39;productivity&#39;&quot; or &quot;Show me all notes tagged with #project&quot;</p><h3>Content Modification Through Obsidian MCP Server</h3><p>You can create and update notes using:</p><ol><li>obsidian_append_content: Adds content to the end of a file</li><li>obsidian_patch_content: Replaces file content entirely</li></ol><p>Example usage:<br>&quot;Create a new note called &#39;Meeting Notes.md&#39; with today&#39;s date as the heading&quot; or &quot;Add a new section to my &#39;Project Ideas.md&#39; file about productivity tools&quot;</p><h3>Property Management in Obsidian MCP Server</h3><p>For managing metadata and frontmatter:</p><ol><li>obsidian_get_properties: Retrieves a note&#39;s frontmatter properties</li><li>obsidian_update_properties: Updates properties while preserving timestamps</li></ol><p>Example usage:<br>&quot;Add the tag #review to my &#39;Project Ideas.md&#39; file&quot; or &quot;Update the status of &#39;Current Project.md&#39; to &#39;in-progress&#39;&quot;</p><h3>Advanced Techniques for Obsidian MCP Server</h3><p>Once you&#39;re comfortable with the basics, you can explore advanced techniques:</p><h3>Creating Structured Notes with Obsidian MCP Server</h3><p>You can implement templates and structured note creation by combining file operations with property management. For example:</p><ol><li>Create a new note with specific frontmatter (title, tags, status)</li><li>Add structured sections based on templates you define</li><li>Link to existing notes for context</li></ol><h3>Implementing Search-and-Update Workflows with Obsidian MCP Server</h3><p>Combine search and modification tools to:</p><ol><li>Find all notes matching specific criteria</li><li>Apply batch updates or tagging</li><li>Create index notes that reference related content</li></ol><h3>Automating Knowledge Management with Obsidian MCP Server</h3><p>Design AI-powered workflows for:</p><ol><li>Daily note creation with automatic linking to relevant notes</li><li>Research summarization and integration into your knowledge base</li></ol><p>Before we conclude, let’s talk about something that we all face during development: API Testing with Postman for your Development Team.</p><p>Yeah, I’ve heard of it as well, <a href="https://www.reddit.com/r/webdev/comments/kl45qq/what_the_hell_happened_to_postman/">Postman is getting worse</a> year by year, but, you are working as a team and you need some collaboration tools for your development process, right? So you paid Postman Enterprise for…. $49/month.</p><p>Now I am telling you: You Don’t Have to:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SzJh_AZ07FvJRZtxDcQySg.png" /><figcaption>APIDog: You Get Everything from Postman Paid Version, But CHEAPER</figcaption></figure><p>That’s right, APIDog gives you all the features that comes with Postman paid version, at a fraction of the cost. Migration has been so easily that you only need to click a few buttons, and APIDog will do everything for you.</p><p><a href="https://bit.ly/3FZck1e">Apidog An integrated platform for API design, debugging, development, mock, and testing</a></p><p>APIDog has a comprehensive, easy to use GUI that makes you spend no time to get started working (If you have migrated from Postman). It’s elegant, collaborate, easy to use, with Dark Mode too!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*5IU81JhalGY8F5Od.png" /><figcaption>APIDog makes you very easy to migrate from Postman with No Learning Curve</figcaption></figure><p>Want a Good Alternative to Postman? APIDog is definitely worth a shot. But if you are the Tech Lead of a Dev Team that really want to dump Postman for something Better, and Cheaper, Check out APIDog!</p><p><a href="https://bit.ly/3FZck1e">Apidog An integrated platform for API design, debugging, development, mock, and testing</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6f44ba3fb279" width="1" height="1" alt=""><hr><p><a href="https://medium.com/towards-agi/getting-started-with-obsidian-mcp-server-a-comprehensive-guide-6f44ba3fb279">Getting Started with Obsidian MCP Server: A Comprehensive Guide</a> was originally published in <a href="https://medium.com/towards-agi">Towards AGI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Devin AI 2.0: A Quick Look]]></title>
            <link>https://medium.com/towards-agi/devin-ai-2-0-a-quick-look-696af42f2b2a?source=rss-d1e94386bbd1------2</link>
            <guid isPermaLink="false">https://medium.com/p/696af42f2b2a</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[devin-ai]]></category>
            <dc:creator><![CDATA[Asaki Sakamoto]]></dc:creator>
            <pubDate>Fri, 04 Apr 2025 14:43:14 GMT</pubDate>
            <atom:updated>2025-04-04T14:43:14.449Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*GBPBvLIMvjoX7sFH.png" /></figure><p>In the rapidly evolving landscape of AI-powered developer tools, Cognition Labs has made a significant splash with the release of Devin 2.0, the next generation of their AI software engineer. Launched on April 3, 2025, this updated version brings a reimagined experience at a dramatically lower price point, positioning it to potentially disrupt how developers interact with AI assistants. Let’s dive into what makes this release noteworthy and how it might impact the software development ecosystem.</p><p>Let’s talk about something that we all face during development: API Testing with Postman for your Development Team.</p><p>Yeah, I’ve heard of it as well, <a href="https://www.reddit.com/r/webdev/comments/kl45qq/what_the_hell_happened_to_postman/">Postman is getting worse</a> year by year, but, you are working as a team and you need some collaboration tools for your development process, right? So you paid Postman Enterprise for…. $49/month.</p><p>Now I am telling you: You Don’t Have to:</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/0*0x37K1r5epLnGsrT.png" /></figure><p>That’s right, APIDog gives you all the features that comes with Postman paid version, at a fraction of the cost. Migration has been so easily that you only need to click a few buttons, and APIDog will do everything for you.</p><p><a href="https://bit.ly/3TdVn6U">How to Migrate Postman Collections/Environments to Apidog</a></p><p><strong>APIDog</strong> has a comprehensive, easy to use GUI that makes you spend no time to get started working (If you have migrated from Postman). It’s elegant, collaborate, easy to use, with Dark Mode too!</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/0*6PZT6kIK6G9pTNdg.png" /></figure><p>Want a Good Alternative to Postman? APIDog is definitely worth a shot. But if you are the Tech Lead of a Dev Team that really want to dump Postman for something Better, and Cheaper, Check out APIDog!</p><p><a href="https://bit.ly/4ebMDGm">Apidog: All-in-One API Platform: Design, Debug, Mock, Test, and Document</a></p><h3>A New Paradigm at a New Price Point</h3><p>Perhaps the most striking change with Devin 2.0 is its pricing structure. According to <a href="https://venturebeat.com/ai/devin-2-0-is-here-cognition-slashes-price-of-ai-software-engineer-to-20-per-month-from-500/">venturebeat.com</a>, Cognition has slashed the price from the previous $500 to a far more accessible $20 per month starting plan. This 96% price reduction represents a strategic shift from positioning Devin as an enterprise-focused tool to one that individual developers and smaller teams can readily adopt.</p><p>“Today, we’re excited to announce Devin 2.0: a new agent-native IDE experience for working with Devin, along with a flexible new plan starting at $20,” the Cognition team shared in their announcement on <a href="https://cognition.ai/blog/devin-2">cognition.ai</a>. This pay-as-you-go approach, as <a href="https://techcrunch.com/2025/04/03/devin-the-viral-coding-ai-agent-gets-a-new-pay-as-you-go-plan/">techcrunch.com</a> describes it, could significantly broaden the tool’s user base.</p><h3>The “Agent-Native IDE” Experience</h3><p>At the core of Devin 2.0 is what Cognition calls an “agent-native IDE experience.” Unlike traditional AI coding assistants that function primarily through chat interfaces, Devin 2.0 integrates directly into a development environment that feels familiar to programmers accustomed to tools like Visual Studio Code.</p><p>This environment allows users to:</p><ul><li>Interact with code in real-time</li><li>Seamlessly switch between AI assistance and manual coding</li><li>Access Devin’s capabilities within the same window where they’re viewing and editing code</li><li>Maintain context throughout the development process</li></ul><p>The interface aims to reduce the friction that typically exists when bouncing between different tools, potentially streamlining workflows and increasing productivity.</p><h3>Parallel Processing with Multiple Devins</h3><p>One of the standout features of Devin 2.0 is the ability to run multiple instances simultaneously. Users can “spin up multiple parallel Devins, each equipped with its own interactive, cloud-based IDE,” according to <a href="https://cognition.ai/blog/devin-2">cognition.ai</a>.</p><p>This capability enables developers to:</p><ul><li>Work on different aspects of a project concurrently</li><li>Assign routine tasks to one instance while focusing on complex problems with another</li><li>Compare different approaches to the same problem</li><li>Scale their AI assistance based on workload demands</li></ul><p>Each Devin instance operates independently, working autonomously while allowing the developer to intervene and provide guidance whenever necessary. This parallel processing approach represents a significant advancement in how AI tools can be leveraged for software development.</p><h3>Collaborative Planning and Specification Refinement</h3><p>Devin 2.0 positions itself as more than just a code generator — it’s a collaborative planning partner. The system now works with developers to scope out tasks before execution, bridging the gap between initial ideas and detailed product requirements documents.</p><p>Starting with raw concepts, Devin quickly presents relevant files, findings, and an initial plan to help refine specifications. This feature addresses one of the common challenges in software development: translating vague requirements into actionable tasks.</p><p>By facilitating this transition, Devin 2.0 potentially reduces miscommunication and rework, helping teams align on objectives and implementation details earlier in the development process.</p><h3>Enhanced Codebase Understanding</h3><p>Cognition has introduced two noteworthy features aimed at deepening Devin’s understanding of existing codebases:</p><h3>Devin Search</h3><p>This functionality lets developers ask questions about their codebase, similar to semantic code search tools but with the added advantage of Devin’s understanding of programming contexts and relationships.</p><h3>Deep Mode</h3><p>For more complex inquiries that require extensive exploration of the codebase, Deep Mode enables Devin to conduct thorough analyses before providing answers.</p><p>As one user shared in the provided tweets, Devin can even understand code with no documentation or comments, demonstrating its ability to infer purpose and patterns from code structure alone.</p><h3>Documentation and Knowledge Management</h3><p>With Devin 2.0, the AI now automatically creates and maintains documentation through a feature called “Devin Wiki.” This wiki includes:</p><ul><li>Detailed architecture diagrams</li><li>Links to source code</li><li>Comprehensive documentation for repositories</li></ul><p>This feature addresses the perennial problem of keeping documentation in sync with code, potentially reducing the maintenance burden on development teams while improving knowledge sharing and onboarding experiences.</p><h3>Efficiency Improvements</h3><p>Cognition claims significant performance gains with Devin 2.0, stating that each ACU (AI Computation Unit) now goes “almost 2x as far.” According to their internal benchmarks of junior-developer tasks, Devin 2.0 completes over 83% more tasks per ACU than its predecessor.</p><p>This efficiency improvement not only translates to cost savings for users but also suggests that the underlying models and algorithms have been substantially refined. If these claims hold up in real-world usage, it represents a meaningful step forward in AI-assisted development productivity.</p><h3>Real-World Applications</h3><p>Devin 2.0’s combination of features opens up numerous possibilities for software teams:</p><ul><li>Rapid prototyping: Quickly turning ideas into functioning code</li><li>Code maintenance: Understanding and updating legacy systems</li><li>Knowledge transfer: Documenting institutional knowledge about codebases</li><li>Developer augmentation: Handling routine tasks while developers focus on creative problem-solving</li><li>Learning and mentorship: Providing explanations and alternative approaches to junior developers</li></ul><p>The pricing change particularly enables smaller teams and individual developers to experiment with these applications, potentially democratizing access to AI-powered development assistance.</p><h3>Limitations and Considerations</h3><p>Despite the impressive advancements, important caveats remain. As <a href="https://techcrunch.com/2025/04/03/devin-the-viral-coding-ai-agent-gets-a-new-pay-as-you-go-plan/">techcrunch.com</a> notes, “Even the best code-generating AI today tends to introduce security vulnerabilities and bugs, studies have found, owing to weaknesses in areas like the ability to understand programming logic. One recent evaluation of Devin found that it completed just three out of 20 tasks successfully.”</p><p>This sobering assessment serves as a reminder that AI coding tools remain assistants rather than replacements for human developers. Users should maintain vigilance regarding:</p><ul><li>Security vulnerabilities in generated code</li><li>Logical errors that may not be immediately apparent</li><li>Over-reliance on AI-generated solutions without proper review</li><li>Potential limitations in handling highly complex or novel programming challenges</li></ul><h3>Implications for the Industry</h3><p>Devin 2.0’s release, particularly at its new price point, may accelerate several trends in the software development landscape:</p><ul><li>Democratization of AI development tools: Making advanced AI assistants accessible to individual developers and small teams</li><li>Evolving developer workflows: Changing how developers interact with their tools and approach problems</li><li>Shifting skill emphasis: Potentially placing greater value on specification, review, and architectural skills rather than routine coding</li><li>Competitive responses: Likely prompting similar moves from competitors in the AI coding assistant space</li></ul><p>The dramatic price reduction could prove particularly disruptive, potentially forcing other players to reconsider their pricing models and accessibility strategies.</p><h3>Conclusion</h3><p>Devin 2.0 represents a significant evolution in AI-assisted software development, combining improved capabilities with dramatically increased accessibility. The shift to an agent-native IDE experience, parallel processing capabilities, and enhanced codebase understanding features all point toward a more seamlessly integrated role for AI in development workflows.</p><p>While questions remain about performance on complex tasks and the need for human oversight, Cognition’s latest offering suggests that AI coding assistants are maturing rapidly. The aggressive pricing strategy indicates confidence in the product’s value proposition and may serve as a catalyst for broader adoption across the industry.</p><p>As with any technological advance, the true impact of Devin 2.0 will be determined by how developers integrate it into their workflows and whether it delivers meaningful productivity gains in real-world scenarios. What’s clear is that the landscape of AI-assisted development continues to evolve at a remarkable pace, with Devin 2.0 representing an important milestone in that journey.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=696af42f2b2a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/towards-agi/devin-ai-2-0-a-quick-look-696af42f2b2a">Devin AI 2.0: A Quick Look</a> was originally published in <a href="https://medium.com/towards-agi">Towards AGI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Microsoft’s Majorana 1: Pioneering the Future of Quantum Computing]]></title>
            <link>https://medium.com/towards-agi/microsofts-majorana-1-pioneering-the-future-of-quantum-computing-7b78ef63ef6b?source=rss-d1e94386bbd1------2</link>
            <guid isPermaLink="false">https://medium.com/p/7b78ef63ef6b</guid>
            <category><![CDATA[microsoft]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Asaki Sakamoto]]></dc:creator>
            <pubDate>Thu, 20 Feb 2025 06:59:39 GMT</pubDate>
            <atom:updated>2025-02-20T06:59:39.884Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*VONJXCAhdjlEXx5n.jpg" /></figure><h3>Introduction to Quantum Computing and Qubits</h3><p>Quantum computing represents a paradigm shift in how we process information. Unlike classical computers, which use bits as the fundamental unit of data (represented as 0s or 1s), quantum computers use <strong>qubits</strong>. Qubits leverage the principles of quantum mechanics — superposition and entanglement — to exist in multiple states simultaneously. This enables quantum computers to solve complex problems exponentially faster than classical systems, with potential applications in cryptography, material science, drug discovery, and optimization.</p><p>However, the power of quantum computing comes with significant challenges. Qubits are notoriously fragile, and maintaining their stability long enough to perform computations remains a major hurdle. This fragility, known as <strong>quantum decoherence</strong>, has driven researchers to explore innovative ways to create more robust qubits. Enter Microsoft’s <strong>Majorana 1</strong> project — a bold initiative aimed at building topological qubits using Majorana fermions, which could revolutionize the field.</p><h3>The Challenge of Quantum Decoherence</h3><p>Quantum decoherence occurs when qubits lose their quantum state due to interactions with their environment, such as temperature fluctuations or electromagnetic noise. Even the slightest disturbance can erase critical information, making error correction a central focus in quantum computing. Current approaches, like superconducting qubits (used by IBM and Google) or trapped ions (pioneered by Honeywell and IonQ), require extreme isolation and cooling to mitigate decoherence. These systems are effective but face scalability issues as the number of qubits grows.</p><h3>Microsoft’s Approach: Topological Qubits</h3><p>Microsoft has taken a fundamentally different route by investing in <strong>topological qubits</strong>. Unlike traditional qubits, which store information in the state of a single particle, topological qubits encode data in the global properties of a material’s structure. This makes them inherently resistant to local disturbances. Imagine braiding strands of a rope: the overall structure remains intact even if individual fibers fray. Similarly, topological qubits protect information through their geometric configuration rather than relying on the stability of individual components.</p><p>The key to this approach lies in harnessing <strong>Majorana fermions</strong> — exotic particles theorized to exist in certain materials under specific conditions.</p><h3>Understanding Majorana Fermions</h3><p>Majorana fermions are unique quantum entities that act as their own antiparticles. First proposed by Italian physicist Ettore Majorana in 1937, they remained a theoretical curiosity until advances in condensed matter physics suggested they could emerge as <strong>quasiparticles</strong> in superconducting materials. These quasiparticles are not elementary particles but collective excitations of electrons that behave like Majorana fermions under controlled conditions.</p><p>In 2012, researchers observed signatures of Majorana fermions in hybrid systems combining semiconductors and superconductors. This discovery opened the door to using their unique properties for quantum computing.</p><h3>The Majorana 1 Project</h3><p>Microsoft’s <strong>Majorana 1</strong> project is an ambitious effort to create stable topological qubits using Majorana fermions. Named after the enigmatic particles themselves, the project represents years of research into materials science, nanotechnology, and quantum theory. The goal is to demonstrate a working topological qubit that can outperform existing technologies in error resistance and scalability.</p><h3>How Majorana 1 Works</h3><p>The experimental setup for Majorana 1 involves three critical components:</p><ol><li><strong>Semiconductor Nanowire</strong>: A nanowire made of indium antimonide (InSb) or similar material serves as the foundation.</li><li><strong>Superconducting Layer</strong>: The nanowire is coated with aluminum, which becomes superconducting at ultra-low temperatures.</li><li><strong>Magnetic Field</strong>: A carefully tuned magnetic field is applied to induce a topological phase in the system.</li></ol><p>When cooled to near absolute zero and subjected to the right conditions, Majorana fermions appear as localized zero-energy states at the ends of the nanowire. These quasiparticles form the basis of a topological qubit. Information is stored not in the individual particles but in the way they are spatially arranged — specifically, through <strong>braiding operations</strong>. By physically moving Majorana fermions around one another, their quantum states become entangled in a way that is inherently protected from local noise.</p><h3>Significance for Quantum Computing</h3><h3>Error Resistance</h3><p>The non-local nature of topological qubits makes them less susceptible to decoherence. Errors that disrupt one part of the system do not easily propagate, reducing the need for extensive error correction.</p><h3>Scalability</h3><p>Current quantum computers require thousands of physical qubits to create a single logical qubit with error correction. Topological qubits could drastically reduce this overhead, enabling practical, large-scale quantum systems.</p><h3>Long-Term Stability</h3><p>Majorana-based qubits could maintain coherence times orders of magnitude longer than superconducting or trapped-ion qubits, making them ideal for complex computations.</p><h3>Challenges and Current Status</h3><p>Despite its promise, the Majorana 1 project faces significant hurdles:</p><ul><li><strong>Material Perfection</strong>: Creating defect-free semiconductor-superconductor interfaces is critical but technically demanding.</li><li><strong>Temperature Constraints</strong>: Operating near absolute zero limits practical applications outside laboratory settings.</li><li><strong>Detection Difficulties</strong>: Confirming the presence of Majorana fermions requires highly sensitive measurements, and false positives have plagued earlier experiments.</li></ul><p>In 2018, Microsoft researchers reported observing Majorana fermions, but subsequent scrutiny raised doubts. The team has since refined their techniques, with Majorana 1 representing a more advanced iteration. While a fully functional topological qubit has yet to be demonstrated, progress in material engineering and measurement precision suggests breakthroughs are on the horizon.</p><h3>Future Prospects</h3><p>If successful, Majorana 1 could redefine the quantum computing landscape. Microsoft envisions a <strong>scalable quantum machine</strong> capable of solving problems intractable for classical systems, such as simulating molecular interactions for drug development or optimizing global supply chains. The company has integrated its quantum efforts into its Azure cloud platform, allowing researchers to experiment with quantum algorithms today while awaiting hardware maturation.</p><p>Long-term, topological qubits could enable <strong>fault-tolerant quantum computers</strong> that operate reliably without constant error correction. This would accelerate advancements in artificial intelligence, cryptography, and beyond.</p><h3>Conclusion</h3><p>Microsoft’s Majorana 1 project embodies the cutting edge of quantum computing research. By leveraging the unique properties of Majorana fermions, the initiative seeks to overcome the Achilles’ heel of quantum systems — decoherence — and unlock unprecedented computational power. While challenges remain, the potential rewards justify the investment. As the race for quantum supremacy intensifies, Majorana 1 stands as a testament to the power of innovative thinking and the relentless pursuit of scientific discovery. Whether it becomes the foundation of the first practical quantum computer or a stepping stone to even greater breakthroughs, its impact on technology and society could be profound.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7b78ef63ef6b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/towards-agi/microsofts-majorana-1-pioneering-the-future-of-quantum-computing-7b78ef63ef6b">Microsoft’s Majorana 1: Pioneering the Future of Quantum Computing</a> was originally published in <a href="https://medium.com/towards-agi">Towards AGI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Top 5 Underrated AI Coding Tools You Should Try Today]]></title>
            <link>https://medium.com/towards-agi/top-5-underrated-ai-coding-tools-you-should-try-today-a382813f9662?source=rss-d1e94386bbd1------2</link>
            <guid isPermaLink="false">https://medium.com/p/a382813f9662</guid>
            <category><![CDATA[cursor]]></category>
            <category><![CDATA[github-copilot]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[ai-coding]]></category>
            <category><![CDATA[coding]]></category>
            <dc:creator><![CDATA[Asaki Sakamoto]]></dc:creator>
            <pubDate>Wed, 19 Feb 2025 09:17:34 GMT</pubDate>
            <atom:updated>2025-02-19T09:17:34.204Z</atom:updated>
            <content:encoded><![CDATA[<p>The AI coding assistant landscape is dominated by big names like GitHub Copilot and ChatGPT, but hidden gems are revolutionizing how developers work. These underrated tools offer unique features that streamline workflows, enhance code quality, and adapt to modern development needs — all while flying under the radar. Let’s explore five standout options that deserve more attention.</p><h3>1. Aide: The AI-Powered IDE</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*z5bD9ZiSolyeQ14I.png" /></figure><p>Aide combines the power of an integrated development environment (IDE) with advanced AI capabilities, making it a versatile alternative to tools like Cursor. Unlike traditional extensions, Aide operates as a full AI-native editor with:</p><ul><li>Real-time code optimization for performance improvements</li><li>Multi-language support (Python, JavaScript, Java, etc.)</li><li>Automatic documentation generation</li><li>Git integration with smart commit messages</li><li>Voice coding and image-based context support</li></ul><p>Developers praise its intuitive chat interface and agentic features that handle complex refactoring tasks. While newer than established IDEs, Aide’s growing popularity (now #3 on OpenRouter) signals its rising potential.</p><p><a href="https://aide.dev/">Aide - Your AI Programming Assistant</a></p><h3>2. Kodu.ai (Claude Coder): Your 24/7 Coding Partner</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*tJITtkWVB4bqDWfH" /></figure><p>This VS Code extension stands out for its adaptive learning and project lifecycle support:</p><ul><li>Observation mode analyzes coding patterns to offer personalized suggestions</li><li>Autonomous agent handles tasks from API integration to error resolution</li><li>Context-aware chat tied to specific files</li><li>Beginner-friendly guidance without overwhelming advanced users</li></ul><p>Kodu.ai shines in legacy code modernization, offering step-by-step refactoring plans while maintaining original functionality. Its unobtrusive interface and focus on developer ergonomics make it ideal for teams balancing speed with code quality.</p><p><a href="https://kodu.ai/">AI Tools to Build Your Product Without Coding Expertise | Kodu.ai</a></p><h3>3. Traycer: The Code Quality Guardian</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*e9c87uj8YHgzMo0z.png" /></figure><p>Specializing in large-scale codebase management, Traycer offers:</p><ul><li>Automated code reviews with four analysis categories:</li><li>Bug detection</li><li>Performance optimization</li><li>Security vulnerabilities</li><li>Code clarity improvements</li><li>Task management system for breaking down complex projects</li><li>Change tracking with easy rollback capabilities</li><li>VS Code integration through a free tier</li></ul><p>Unique to Traycer is its “review mode,” where AI suggests improvements without altering original code — perfect for teams wanting AI assistance without surrendering control.</p><p><a href="https://traycer.ai/">Traycer: AI-Powered Pair Programming</a></p><h3>4. OpenHands: The Open-Space Powerhouse</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*nyzUiyZ_me8soNZ3" /></figure><p>Ranked #1 on SWE-bench, this open-source platform excels at automating development workflows:</p><ul><li>Project scaffolding with intelligent directory structuring</li><li>Dependency management across Python/JavaScript ecosystems</li><li>GitHub Actions integration for CI/CD pipelines</li><li>API endpoint generation</li><li>Multi-LLM compatibility (choose your preferred AI model)</li></ul><p>OpenHands’ AgentHub lets developers share custom automation scripts, creating a collaborative ecosystem. Its ability to handle everything from documentation to production deployments makes it a Swiss Army knife for full-stack projects.</p><p><a href="https://github.com/All-Hands-AI/OpenHands">GitHub - All-Hands-AI/OpenHands: 🙌 OpenHands: Code Less, Make More</a></p><h3>5. Zed Editor: The Performance Maverick</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_hGDOI440ClewBuH" /></figure><p>While not strictly an AI tool, Zed’s Claude 3.5 Sonnet integration redefines editor-assisted coding:</p><ul><li>Inline code transformations via natural language prompts</li><li>/slash commands for rapid context building</li><li>Multiplayer editing with AI-assisted conflict resolution</li><li>Lightning-fast performance even in massive codebases</li></ul><p>Zed’s minimal interface hides powerful features like terminal integration and real-time collaboration, making it ideal for developers prioritizing speed and efficiency over ecosystem lock-in.</p><p><a href="https://zed.dev/">https://zed.dev/</a></p><h3>Why These Tools Matter</h3><p>The coding landscape is evolving beyond autocomplete and chatbot helpers. These underrated tools represent the next wave of AI assistance:</p><ol><li>Context-aware solutions that adapt to specific projects</li><li>Quality-first approaches balancing speed with maintainability</li><li>Open ecosystems encouraging customization over rigid workflows</li></ol><p>While mainstream tools focus on code generation, these alternatives address harder problems: technical debt reduction, legacy modernization, and team onboarding. Their free tiers and open-source options lower barriers to experimentation — a smart move for developers wanting AI leverage without vendor lock-in.</p><p>The future of coding isn’t about replacing developers, but amplifying their capabilities. Tools like Traycer’s review system and OpenHands’ automation framework exemplify this philosophy, offering intelligent assistance while keeping engineers firmly in control. As AI matures, these under-the-radar options might just become tomorrow’s essentials.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a382813f9662" width="1" height="1" alt=""><hr><p><a href="https://medium.com/towards-agi/top-5-underrated-ai-coding-tools-you-should-try-today-a382813f9662">Top 5 Underrated AI Coding Tools You Should Try Today</a> was originally published in <a href="https://medium.com/towards-agi">Towards AGI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>