Leveling up your AIP agents with the Palantir API

Announcements
, ,
1

As we move into 2025, it seems poised to be the year of the agent. At Palantir, we’re well-prepared to assist our users in harnessing this development. Over the past year, we’ve successfully launched two applications designed to help users create agentic workflows. In this post, I’d like to provide a brief overview of these applications and to walk through where we’re excited to see users take AIP Agents in 2025 with custom API integrations.

Agents in the Palantir Platform

Use AIP Agent Studio to build agents with access to the Ontology or custom retrieved context, provide them with tools to run Actions and Functions to execute custom logic, and define the application state in which your agent will be used to customize its inputs and outputs for a task.

You can start with using agents within Agent Studio or in AIP Threads. Just want to get started with ad-hoc analysis with LLMs before building out an agent? Start with AIP Threads and you can upgrade to an agent later with one-click.

Ready to build a larger agentic application? The AIP Interactive widget allows you to embed an agent in your Workshop applications to fit in the custom UI needed to solve your specific task. It’s easy to connect your Workshop application’s state to your agent using application variables to build more complex interactions beyond the widget’s UI.

Go further with agents in the Palantir APIs

For some more custom tasks, in-platform applications or the built-in UI options where you can embed agents may not be enough (e.g., needing to embed your agent in a third-party application or a fully custom UI).

For these cases, we added agents to the Palantir APIs to give you full control over how you build your agentic applications.

What can I do with the APIs?

Easily build multi-shot interactions with your agents over the API, using its options to:

  • Start new conversations for a given task or context by creating a new session with your agent.
  • Orchestrate complex back-and-forth task prompts with the streaming or blocking APIs, with built-in state management to track these updates to your sessions for you.*
  • Provide custom application inputs to the agent through the options for application state in the API (these use the parameter naming convention, but refer to the Application state/variables in Agent Studio). Use the parameterInputs field in requests to provide inputs. Use the parameterUpdates field for blocking responses (or load the session exchange after streaming) to read custom outputs.

Want some inspiration of what you build using these APIs? Check out a few of the starter ideas below:

  • Automatically generate relevant follow-up suggestions for a user based on the most recent exchanges in the session for custom rendering in your app. For example, use the AIP Agents API to load the recent exchanges for the session, and pass these as inputs to a custom AIP Logic Function to generate suggested questions.
  • Create a proactive messaging flow by automatically creating and seeding a session with an agent based on an automated trigger. Send the initial message from the Agent to a user in a push-notification style.
  • Build a custom bot service for third-party chat applications and websites, such as Slack or Microsoft Teams bots.

*Note: while AIP agents are in beta, sessions are currently limited to a lifetime of 24 hours since the last interaction. This restriction is expected to be lifted in future so you can continue your interactions with sessions a day or even a year later from where you last left off.

Simplifying development with the Platform and Ontology SDKs

When you want to focus on the business logic of your application’s interactions with agents and avoid the technical details of calling the platform APIs, we suggest using the Python and Typescript SDKs for a simpler developer experience.

The platform SDKs can also be used alongside an Ontology SDK. While the platform SDKs are generic libraries that allow you to interact with any agent (or other supported Palantir resource type) by specifying its identifier as an argument, the Ontology SDKs (OSDKs) are specialized libraries generated based on the Ontology types you configure for your OSDK Developer Console application.

When you have a limited set of known object types you want to work with, it’s best to work with a custom OSDK for your application to provide a more intuitive interface for working with these in your application code. You can use objects loaded through your OSDK as inputs to agents you interact with through the generic platform SDK libraries, and easily swap out the agent used for interactions at runtime by changing the agent you specify as an argument.

Working with an OSDK and the platform SDKs currently requires you to use two separate clients, each created in Developer Console (see Applications and OAuth clients for details). To simplify the number of clients you need to manage and use in your application, we’re adding support in Dev Console which will allow you to configure an OSDK client to support interacting with agents in the platform SDKs. This feature is currently in beta for limited enrollments, with wider rollout coming soon.

Have you already tried out building agentic applications, or are you just getting started in your explorations? Let us know in the comments below what you’re excited to try building this year!

Note on availability: AIP agents and AIP Agent Studio are currently available in Beta, including on Dev Tier stacks. To use AIP agents, you will need to first enable Agent Studio in the Application access section in Control Panel.

10 Likes
2

While I was writing this post I wondered what it would look like if I tried to fit as many song-based quotes as possible in it. With the recent Grammy Awards in mind (and wanting to keep a high calibre of song quotes), I wanted to try building something with this kaggle dataset and the agent APIs to allow adding some custom UI flair :sparkles:.

While we eventually decided to go with a less-musically themed post, I wanted to publish the example to show just how easy it is to pull an AIP agent into a custom application!

Here’s an example agent I built to help generate these song quotes, with the code for a quick streamlit app, powered using agents with the platform SDK, to show these off in a custom UI:

  • demo video

  • example python code

# app.py

# import the palantir platform SDK
import foundry
import foundry.v2

# import libraries for our custom app and loading configuration for the SDK client
import streamlit as st
from dotenv import dotenv_values
from streamlit_extras.let_it_rain import rain

"""Example .env configuration required:
HOSTNAME=<your hostname, e.g. example.com>
TOKEN=<copy using instructions from https://www.palantir.com/docs/foundry/api/v2/general/overview/authentication/#creating-an-api-bearer-token>
"""
CONFIGURATION = dotenv_values(".env")


@st.cache_resource
def get_client():
    auth = foundry.UserTokenAuth(token=CONFIGURATION["TOKEN"])
    return foundry.v2.FoundryClient(auth=auth, hostname=CONFIGURATION["HOSTNAME"])


def reset_session():
    st.session_state["messages"] = []
    st.session_state["session_rid"] = None


with st.sidebar:
    agent_rid = st.text_input("AIP Agent RID", key="aip_agent_rid")
    "[Create a new AIP Agent](https://www.palantir.com/docs/foundry/agent-studio/getting-started/#create-an-aip-agent)"

st.title("🎵 Shoe-horned song quote generator")
st.button("🔄", on_click=reset_session)

if "messages" not in st.session_state:
    st.session_state["messages"] = []

for msg in st.session_state.messages:
    st.chat_message(msg["role"]).write(msg["content"])

if prompt := st.chat_input():
    if not agent_rid:
        st.info("Please add your AIP AGENT RID to continue.")
        st.stop()

    foundry_client = get_client()

    if "session_rid" not in st.session_state or not st.session_state["session_rid"]:
        session = foundry_client.aip_agents.Agent.Session.create(agent_rid, preview=True)
        session_rid = session.rid
        st.session_state["session_rid"] = session_rid
    else:
        session_rid = st.session_state["session_rid"]

    st.session_state.messages.append({"role": "user", "content": prompt})
    st.chat_message("user").write(prompt)

    with foundry_client.aip_agents.Agent.Session.with_streaming_response.streaming_continue(
        agent_rid,
        session_rid,
        parameter_inputs={},
        user_input={"text": prompt},
        preview=True
    ) as response:

        # Stream the response from the agent to display in the UI as it's generated
        def get_chunk():
            for chunk in response.iter_bytes():
                yield chunk.decode("utf-8")
        st.chat_message("assistant").write_stream(get_chunk)

    # Once the response is fully generated, load the full details of the exchange
    # including our updated application variables to use for updating our custom application state
    updated_session = foundry_client.aip_agents.Agent.Session.Content.get(
        agent_rid,
        session_rid,
        preview=True
    )
    last_exchange = updated_session.exchanges[-1]

    # Display our updated application state
    emoji = last_exchange.result.parameter_updates.get("outputEmoji")
    if emoji:
        rain(font_size=24, emoji=emoji.value, animation_length="10s", falling_speed=2)

    st.session_state.messages.append({"role": "assistant", "content": last_exchange.result.agent_markdown_response})
3 Likes