{"id":2546,"date":"2025-10-01T14:13:24","date_gmt":"2025-10-01T14:13:24","guid":{"rendered":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/2025\/10\/01\/introducing-microsoft-agent-framework-preview-making-ai-agents-simple-for-every-developer\/"},"modified":"2025-10-01T14:13:24","modified_gmt":"2025-10-01T14:13:24","slug":"introducing-microsoft-agent-framework-preview-making-ai-agents-simple-for-every-developer","status":"publish","type":"post","link":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/2025\/10\/01\/introducing-microsoft-agent-framework-preview-making-ai-agents-simple-for-every-developer\/","title":{"rendered":"Introducing Microsoft Agent Framework (Preview): Making AI Agents Simple for Every Developer"},"content":{"rendered":"

Building AI agents shouldn\u2019t be rocket science. Yet many developers find themselves wrestling with complex orchestration logic, struggling to connect multiple AI models, or spending weeks building hosting infrastructure just to get a simple agent into production.<\/p>\n

What if building an AI agent could be as straightforward as creating a web API or console application?<\/p>\n

Agents and Workflows<\/h2>\n

Before we dive deeper, let\u2019s define the two core building blocks of agent systems: agents and workflows.<\/p>\n

Agents<\/h3>\n

Across the web, you\u2019ll find many definitions of agents. Some conflicting, some overlapping.<\/p>\n

For this post, we\u2019ll keep it simple:<\/p>\n

Agents are systems that accomplish objectives.<\/strong><\/p>\n\n

Agents become more capable when equipped with the following:<\/p>\n

Reasoning and decision-making<\/strong>: Powered by AI Models (LLMs), search algorithms, or planning and decision-making systems.
\nTool usage<\/strong>: Access to Model Context Protocol (MCP) servers, code execution, and external APIs.
\nContext awareness<\/strong>: Informed by chat history, threads, vector stores, enterprise data, or knowledge graphs.<\/p>\n

These capabilities allow agents to operate more autonomously, adaptively, and intelligently.<\/p>\n

Workflows<\/h3>\n

As objectives grow in complexity, they need to be broken down into manageable steps. That\u2019s where workflows come in.<\/p>\n

Workflows define the sequence of steps required to achieve an objective.<\/strong><\/p>\n

Imagine you\u2019re launching a new feature on your business website. If it\u2019s a simple update, you might go from idea to production in a few hours. But for more complex initiatives, the process might include:<\/p>\n

Requirement gathering
\nDesign and architecture
\nImplementation
\nTesting
\nDeployment<\/p>\n

A few important observations:<\/p>\n

Each step may contain subtasks.
\nDifferent specialists may own different phases.
\nProgress isn\u2019t always linear. Bugs found during testing may send you back to implementation.
\nSuccess depends on planning, orchestration, and communication across stakeholders.<\/p>\n

Agents + Workflows<\/h3>\n

Workflows don\u2019t require agents, but agents can supercharge them.<\/p>\n

When agents are equipped with reasoning, tools, and context, they can optimize workflows.<\/p>\n

This is the foundation of multi-agent systems, where agents collaborate within workflows to achieve complex goals.<\/p>\n

Meet Microsoft Agent Framework<\/h2>\n

Microsoft Agent Framework is a comprehensive set of .NET libraries that reduces the complexity of agent development. Whether you\u2019re building a simple chatbot or orchestrating multiple AI agents in complex workflows, Microsoft Agent Framework provides the tools you need to:<\/p>\n

Build<\/strong> agents with minimal boilerplate code
\nOrchestrate<\/strong> multi-agent workflows with ease
\nHost<\/strong> and deploy agents using familiar .NET patterns
\nMonitor<\/strong> and observe agent behavior in production<\/p>\n

For more details, see the Introducing Microsoft Agent Framework post in the Foundry blog<\/a>.<\/p>\n

Built on Proven Foundations<\/h3>\n

Microsoft Agent Framework leverages established technologies to simplify agent development for .NET developers:<\/p>\n

Semantic Kernel<\/strong> \u2013 Provides robust orchestration
\nAutoGen<\/strong> \u2013 Enables advanced multi-agent collaboration and cutting-edge research-driven techniques
\nMicrosoft.Extensions.AI<\/strong> \u2013 Delivers standardized AI building blocks for .NET.<\/p>\n

By combining these technologies, Agent Framework offers reliability, flexibility, and a developer-friendly API. This allows you to build and deploy powerful AI agents quickly and efficiently.<\/p>\n

Start Simple: Build Your First Agent in Minutes<\/h2>\n

Getting started with Microsoft Agent Framework is simple. In the following example, you\u2019ll build a creative writing agent that generates engaging short stories.<\/p>\n

The fastest way to try it out is to open the Hello World Agents sample<\/a> in GitHub Codespaces:<\/p>\n

<\/a><\/p>\n

If you prefer, you can follow the step-by-step instructions below to set up the project on your own machine.<\/p>\n

Step 0: Configure prerequisites<\/h3>\n

To get started, you\u2019ll need the following:<\/p>\n

.NET 9 SDK or greater<\/a>
\nA GitHub Personal Access Token (PAT) with models scope. You can create one in you can create in your GitHub settings<\/a>. For more details, see the GitHub documentation<\/a><\/p>\n

This project can use GitHub-hosted models so you\u2019ll need to provide the GitHub Personal Access Token (PAT) to your application using the GITHUB_TOKEN environment variable.<\/p>\n

Windows<\/h4>\n

setx GITHUB_TOKEN “YOUR-GITHUB-TOKEN”
\n# Restart your shell to pick up the value<\/p>\n

Linux \/ Mac<\/h4>\n

export GITHUB_TOKEN=”YOUR-GITHUB-TOKEN”<\/p>\n

Step 1: Set Up Your Project<\/h3>\n

Create a new C# console application and install the Agent Framework packages:<\/p>\n

dotnet new console -o HelloWorldAgents
\ncd HelloWorldAgents
\ndotnet add package Microsoft.Agents.AI –prerelease<\/p>\n

You\u2019ll also need to install the following packages to use the models from GitHub models.<\/p>\n

dotnet add package OpenAI
\ndotnet add package Microsoft.Extensions.AI.OpenAI –prerelease
\ndotnet add package Microsoft.Extensions.AI<\/p>\n

Step 2: Write Your Agent<\/h3>\n

Add this code to your Program.cs<\/em> file to create a story-writing agent:<\/p>\n

using Microsoft.Extensions.AI;
\nusing Microsoft.Agents.AI;
\nusing OpenAI;
\nusing OpenAI.Chat;
\nusing System.ClientModel;<\/p>\n

IChatClient chatClient =
\n new ChatClient(
\n “gpt-4o-mini”,
\n new ApiKeyCredential(Environment.GetEnvironmentVariable(“GITHUB_TOKEN”)!),
\n new OpenAIClientOptions { Endpoint = new Uri(“https:\/\/models.github.ai\/inference”) })
\n .AsIChatClient();<\/p>\n

AIAgent writer = new ChatClientAgent(
\n chatClient,
\n new ChatClientAgentOptions
\n {
\n Name = “Writer”,
\n Instructions = “Write stories that are engaging and creative.”
\n });<\/p>\n

AgentRunResponse response = await writer.RunAsync(“Write a short story about a haunted house.”);<\/p>\n

Console.WriteLine(response.Text);<\/p>\n

Run your application<\/p>\n

That\u2019s it! In just a few lines of code, you have a fully functional AI agent.<\/p>\n

The Power of Abstraction<\/h3>\n

Microsoft Agent Framework is designed around powerful abstractions that simplify agent development.<\/p>\n

At its core is the AIAgent abstraction, which provides a unified interface for building agents. The flexibility to use any compatible AI model provider comes from Microsoft.Extensions.AI, which standardizes model access through the IChatClient interface.<\/p>\n

The ChatClientAgent implementation of AIAgent accepts any IChatClient, allowing you to easily choose between providers such as:<\/p>\n

OpenAI
\nAzure OpenAI
\nFoundry Local
\nOllama
\nGitHub Models
\nMany others<\/p>\n

This means you can swap providers or integrate new ones without changing your agent code. The same AIAgent interface works seamlessly with:<\/p>\n

Azure Foundry Agents<\/strong>
\nOpenAI Assistants<\/strong>
\nCopilot Studio<\/strong>
\nMany others<\/p>\n

If you\u2019ve built agents using different SDKs or platforms, using Microsoft Agent Framework is straightforward. You get a consistent developer experience and can leverage orchestration, hosting, and monitoring features.<\/p>\n

Scale Up: Orchestrate Multiple Agents<\/h2>\n

Single agents are powerful, but real-world scenarios often require multiple specialized agents working together. Maybe your writing agent creates great content, but you also need an editor to polish it, or a fact-checker to verify details.<\/p>\n

Agent Framework makes multi-agent orchestration as simple as connecting building blocks.<\/p>\n

Adding Specialized Agents<\/h3>\n

Let\u2019s enhance our story example by adding an editor agent to review and improve the writer\u2019s output:<\/p>\n

\/\/ Create a specialized editor agent
\nAIAgent editor = new ChatClientAgent(
\n chatClient,
\n new ChatClientAgentOptions
\n {
\n Name = “Editor”,
\n Instructions = “Make the story more engaging, fix grammar, and enhance the plot.”
\n });<\/p>\n

Building Workflows<\/h3>\n

Now comes the magic \u2013 connecting these agents in a workflow.<\/p>\n

Install the Microsoft.Agents.Workflows NuGet package:<\/p>\n

dotnet add package Microsoft.Agents.AI.Workflows –prerelease<\/p>\n

Create a workflow to orchestrates your agents:<\/p>\n

\/\/ Create a workflow that connects writer to editor
\nWorkflow workflow =
\n AgentWorkflowBuilder
\n .BuildSequential(writer, editor);<\/p>\n

AIAgent workflowAgent = await workflow.AsAgentAsync();<\/p>\n

AgentRunResponse workflowResponse =
\n await workflowAgent.RunAsync(“Write a short story about a haunted house.”);<\/p>\n

Console.WriteLine(workflowResponse.Text);<\/p>\n

The Result<\/h3>\n

Now when you run your application, the writer creates the initial story, and the editor automatically reviews and improves it. The entire workflow appears to the outside world as a single, more capable agent.<\/p>\n\n

This pattern scales to any complexity:<\/p>\n

Research workflows<\/strong>: Researcher \u2192 Fact-checker \u2192 Summarizer
\nContent pipelines<\/strong>: Writer \u2192 Editor \u2192 SEO Optimizer \u2192 Publisher
\nCustomer service<\/strong>: Intent Triage \u2192 Customer Specialist Agent \u2192 Quality Reviewer<\/p>\n

The key takeaway here is, complex agent systems are compositions of simple, focused agents.<\/p>\n

All Types of Workflows<\/h3>\n

The example above uses a sequential workflow<\/strong>, where agents process tasks one after another, each building on the previous agent\u2019s output. However, Microsoft Agent Framework supports a variety of workflow patterns to fit different requirements:<\/p>\n

Sequential<\/strong>: Agents execute in order, passing results along the chain.
\nConcurrent<\/strong>: Multiple agents work in parallel, addressing different aspects of a task simultaneously.
\nHandoff<\/strong>: Responsibility shifts between agents based on context or outcomes.
\nGroupChat<\/strong>: Agents collaborate in a shared, real-time conversational space.<\/p>\n

These flexible workflow types enable orchestration for everything from simple pipelines to dynamic, multi-agent collaboration.<\/p>\n

Empower Agents with Tools<\/h2>\n

Microsoft Agent Framework makes it incredibly easy to give your agents access to external functions, APIs, and services so your agents can take action.<\/p>\n

Creating Agent Tools<\/h3>\n

Let\u2019s enhance our writing agent with some useful tools. In our story example, we might want agents that can do the following:<\/p>\n

[Description(“Gets the author of the story.”)]
\nstring GetAuthor() => “Jack Torrance”;<\/p>\n

[Description(“Formats the story for display.”)]
\nstring FormatStory(string title, string author, string story) =>
\n $”Title: {title}nAuthor: {author}nn{story}”;<\/p>\n

Connecting Tools to Agents<\/h3>\n

Adding these tools to your agent is straightforward. Here\u2019s a modified version of our writer agent configured to use the tools defined earlier.<\/p>\n

AIAgent writer = new ChatClientAgent(
\n chatClient,
\n new ChatClientAgentOptions
\n {
\n Name = “Writer”,
\n Instructions = “Write stories that are engaging and creative.”,
\n ChatOptions = new ChatOptions
\n {
\n Tools = [
\n AIFunctionFactory.Create(GetAuthor),
\n AIFunctionFactory.Create(FormatStory)
\n ],
\n }
\n });<\/p>\n

Running the application again would result in a formatted story per the template you provided in FormatStory.<\/p>\n

**Title: The Haunting of Blackwood Manor**
\n**Author: Jack Torrance**<\/p>\n

On the outskirts of a quaint village, a grand but crumbling mansion, known as Blackwood Manor, loomed against the twilight sky. Locals spoke in hushed tones about the house, claiming it was haunted by the spirits of its former inhabitants, who had mysteriously vanished decades ago. Tales of flickering lanterns, echoing whispers, and the ghostly figure of a woman in white gliding through the halls filled the village\u2019s atmosphere with a sense of dread
\n\/\/…<\/p>\n

Beyond Simple Functions<\/h3>\n

Because Microsoft Agent Framework builds on Microsoft.Extensions.AI, your agents can use more robust tools including:<\/p>\n

Model Context Protocol (MCP) servers<\/strong> \u2013 Connect to external services like databases, APIs, and third-party tools
\nHosted tools<\/strong> \u2013 Access server-side tools like Code Interpreter, Bing Grounding, and many more<\/p>\n

For example, you could connect to an MCP server that provides database access, web search, or even hardware control. Learn more about building MCP integrations in our MCP client quickstart<\/a>.<\/p>\n

Deploy with Confidence: Hosting Made Simple<\/h2>\n

Getting agents into production shouldn\u2019t mean learning a new deployment model. Microsoft Agent Framework integrates seamlessly with the .NET hosting patterns you already use.<\/p>\n

Minimal Web API Integration<\/h3>\n

Using your agent in a REST API is a few lines of code.<\/p>\n

In an ASP.NET Minimal Web API, start by registering your IChatClient:<\/p>\n

builder.AddOpenAIClient(“chat”)
\n .AddChatClient(Environment.GetEnvironmentVariable(“MODEL_NAME”)!);<\/p>\n

Use the Microsoft.Agents.AI.Hosting<\/strong> NuGet package to register your agents:<\/p>\n

builder.AddAIAgent(“Writer”, (sp, key) =>
\n{
\n var chatClient = sp.GetRequiredService<IChatClient>();<\/p>\n

return new ChatClientAgent(
\n chatClient,
\n name: key,
\n instructions:
\n “””
\n You are a creative writing assistant who crafts vivid,
\n well-structured stories with compelling characters based on user prompts,
\n and formats them after writing.
\n “””,
\n tools: [
\n AIFunctionFactory.Create(GetAuthor),
\n AIFunctionFactory.Create(FormatStory)
\n ]
\n );
\n});<\/p>\n

builder.AddAIAgent(
\n name: “Editor”,
\n instructions:
\n “””
\n You are an editor who improves a writer\u2019s draft by providing 4\u20138 concise recommendations and
\n a fully revised Markdown document, focusing on clarity, coherence, accuracy, and alignment.
\n “””);<\/p>\n

Once registered, your agents are available anywhere in your app:<\/p>\n

app.MapGet(“\/agent\/chat”, async (
\n [FromKeyedServices(“Writer”)] AIAgent writer,
\n [FromKeyedServices(“Editor”)] AIAgent editor,
\n HttpContext context,
\n string prompt) =>
\n{
\n Workflow workflow =
\n AgentWorkflowBuilder
\n .CreateGroupChatBuilderWith(agents =>
\n new AgentWorkflowBuilder.RoundRobinGroupChatManager(agents)
\n {
\n MaximumIterationCount = 2
\n })
\n .AddParticipants(writer, editor)
\n .Build();<\/p>\n

AIAgent workflowAgent = await workflow.AsAgentAsync();<\/p>\n

AgentRunResponse response = await workflowAgent.RunAsync(prompt);
\n return Results.Ok(response);
\n});<\/p>\n

Production-Ready Features<\/h3>\n

Microsoft Agent Framework hosting includes everything you need for production:<\/p>\n

Configuration<\/strong> \u2013 Manage agent settings through standard .NET configuration
\nDependency injection<\/strong> \u2013 Integrate with your existing DI containers and practices
\nMiddleware support<\/strong> \u2013 Add authentication, rate limiting, or custom logic<\/p>\n

Deploy<\/h3>\n

Microsoft Agent Framework doesn\u2019t reinvent deployment. If you know how to ship a .NET app, you already know how to ship agents.<\/p>\n

No new tooling. No special hosting model. Just add agents and deploy wherever .NET runs.<\/p>\n

Observe and Improve: Built-in Monitoring<\/h2>\n

Production agents need observability. Microsoft Agent Framework provides comprehensive monitoring that integrates with your existing observability stack.<\/p>\n

OpenTelemetry Integration<\/h3>\n

Enable detailed telemetry with a single line:<\/p>\n

\/\/ Enhanced telemetry for all your agents
\nwriter.WithOpenTelemetry();
\neditor.WithOpenTelemetry();<\/p>\n

This captures:<\/p>\n

Conversation flows<\/strong> \u2013 Visualize how messages move between agents
\nModel usage<\/strong> \u2013 Track token consumption, model selection, and costs
\nPerformance metrics<\/strong> \u2013 Monitor response times and throughput
\nError tracking<\/strong> \u2013 Identify and debug issues quickly<\/p>\n

Rich Dashboards<\/h3>\n

When connected to your existing observability platforms like:<\/p>\n

Aspire<\/strong>
\nAzure Monitor<\/strong>
\nGrafana<\/strong>
\nMany others<\/p>\n

You get detailed insights into agent behavior, helping you optimize performance and identify issues before they affect users.<\/p>\n

OpenTelemetry with Aspire<\/h3>\n

To send agent telemetry to the Aspire dashboard, enable OpenTelemetry and allow sensitive data for richer insights.<\/p>\n

Set EnableSensitiveTelemetryData to true when configuring your client:<\/p>\n

builder
\n .AddAzureChatCompletionsClient(“chat”, settings =>
\n {
\n settings.EnableSensitiveTelemetryData = true;
\n })
\n .AddChatClient(Environment.GetEnvironmentVariable(“MODEL_NAME”)!);<\/p>\n

Then, configure Aspire to recognize telemetry sources:<\/p>\n

public static TBuilder ConfigureOpenTelemetry<TBuilder>(this TBuilder builder) where TBuilder : IHostApplicationBuilder
\n{
\n builder.Logging.AddOpenTelemetry(logging =>
\n {
\n \/\/…
\n })
\n .AddTraceSource(“Experimental.Microsoft.Extensions.AI.*”);<\/p>\n

builder.Services.AddOpenTelemetry()
\n .WithMetrics(metrics =>
\n {
\n metrics.AddAspNetCoreInstrumentation()
\n .AddHttpClientInstrumentation()
\n .AddRuntimeInstrumentation()
\n .AddMeter(“Experimental.Microsoft.Extensions.AI.*”);
\n })
\n .WithTracing(tracing =>
\n {
\n tracing.AddSource(builder.Environment.ApplicationName)
\n .AddSource(“Experimental.Microsoft.Extensions.AI.*”)
\n .AddAspNetCoreInstrumentation()
\n .AddHttpClientInstrumentation();
\n });
\n \/\/…
\n}<\/p>\n

With this setup, Aspire dashboards show detailed telemetry including conversation flows, model usage, performance metrics, and error tracking.<\/p>\n\n

Ensure Quality: Evaluation and Testing<\/h2>\n

Trust in AI systems comes from rigorous evaluation. Microsoft Agent Framework can easily integrate with Microsoft.Extensions.AI.Evaluations to help you build reliable, trustworthy agent systems.<\/p>\n

This enables:<\/p>\n

Automated testing<\/strong> \u2013 Run evaluation suites as part of your CI\/CD pipeline
\nQuality metrics<\/strong> \u2013 Measure relevance, coherence, and safety
\nRegression detection<\/strong> \u2013 Catch quality degradation before deployment
\nA\/B testing<\/strong> \u2013 Compare different configurations<\/p>\n

See how to get started with evaluations using Microsoft.Extensions.AI.Evaluations<\/a>.<\/p>\n

Start Building Agents Today<\/h2>\n

Microsoft Agent Framework transforms agent development from a complex, specialized skill into something every .NET developer can master. Whether you\u2019re building a chatbot or orchestrating multiple AI agents in complex workflows, Microsoft Agent Framework provides a clear path forward.<\/p>\n

Key Takeaways<\/h3>\n

Simple by Design<\/strong>: Get started with just a few lines of code. Create your first agent in minutes, not days.
\nScales with You<\/strong>: Start with a single agent, then easily add workflows, tools, hosting, and monitoring as your needs grow.
\nBuilt on Proven Technology<\/strong>: Microsoft Agent Framework brings together the best from AutoGen and Semantic Kernel. It builds on Microsoft.Extensions.AI, a unified foundation for modern AI development, to deliver a robust and cohesive experience for .NET developers.
\nProduction Ready<\/strong>: Deploy using familiar .NET patterns with built-in observability, evaluation, and hosting capabilities.<\/p>\n

What\u2019s Next?<\/h3>\n

Ready to start building?<\/p>\n

Run the Hello World agent sample<\/a>.<\/p>\n

Then, head over to the Microsoft Agent Framework documentation<\/a> to continue learning.<\/p>\n

The future of software development includes AI agents as first-class components in modern software development. Microsoft Agent Framework ensures that future is accessible to every .NET developer.<\/p>\n

The post Introducing Microsoft Agent Framework (Preview): Making AI Agents Simple for Every Developer<\/a> appeared first on .NET Blog<\/a>.<\/p>","protected":false},"excerpt":{"rendered":"

Building AI agents shouldn\u2019t be rocket science. Yet many developers find themselves wrestling with complex orchestration logic, struggling to connect […]<\/p>\n","protected":false},"author":0,"featured_media":0,"comment_status":"","ping_status":"","sticky":false,"template":"","format":"standard","meta":{"site-sidebar-layout":"default","site-content-layout":"","ast-site-content-layout":"default","site-content-style":"default","site-sidebar-style":"default","ast-global-header-display":"","ast-banner-title-visibility":"","ast-main-header-display":"","ast-hfb-above-header-display":"","ast-hfb-below-header-display":"","ast-hfb-mobile-header-display":"","site-post-title":"","ast-breadcrumbs-content":"","ast-featured-img":"","footer-sml-layout":"","ast-disable-related-posts":"","theme-transparent-header-meta":"","adv-header-id-meta":"","stick-header-meta":"","header-above-stick-meta":"","header-main-stick-meta":"","header-below-stick-meta":"","astra-migrate-meta-layouts":"default","ast-page-background-enabled":"default","ast-page-background-meta":{"desktop":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"ast-content-background-meta":{"desktop":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"footnotes":""},"categories":[7],"tags":[],"class_list":["post-2546","post","type-post","status-publish","format-standard","hentry","category-dotnet"],"_links":{"self":[{"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/posts\/2546","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/types\/post"}],"replies":[{"embeddable":true,"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/comments?post=2546"}],"version-history":[{"count":0,"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/posts\/2546\/revisions"}],"wp:attachment":[{"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/media?parent=2546"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/categories?post=2546"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/tags?post=2546"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}