Os axentes de IA non están listos para a produción - e o control de acceso pode ser a razón

-Daniel Bass

A mellora do rendemento das aplicacións a través do uso de axentes de IA está a converterse nunha práctica moi común - xa sexa debido a hip-hop en toda a industria ou casos de uso útiles reais.

Estes axentes de IA, con todo, a miúdo requiren acceso a datos altamente sensibles, introducindo riscos de seguridade significativos.Os asistentes de IA expoñen información sensible do pacientee varios axentes AI comprometidos a travésataques sofisticados de inxección rápida. .

A protección dos axentes de IA neste contexto está a ser tan importante como as capacidades dos propios axentes de IA, se non máis.

Para solucionar este problema, enPermiso.euLevamos un tempo traballando nun enfoque estruturado de seguridade que quero presentarvos hoxe:

O marco dos catro perímetros. .

Este método proporciona unha estratexia integral para protexer os axentes de IA mediante a implementaciónControl de acceso finamente granulado, asegurando o cumprimento e mitigando potenciais vectores de ataque. Antes de entrar na solución, falemos máis sobre o espazo do problema.

O problema: riscos de seguridade de IA en dominios sensibles

As medidas tradicionais de seguridade de aplicacións e os mecanismos de control de acceso faltan cando se trata de manexar os axentes de IA.Control de acceso baseado en funcións (RBAC)Excel na xestión de permisos estáticos, loitan coa natureza dinámica das respostas de IA. A diferenza das aplicacións tradicionais onde os mapas de entrada para saídas predictibles e os patróns de acceso están ben definidos, a IA xera respostas únicas para cada consulta.

The way AI systems access data also doesn’t fit security standards. To provide accurate and helpful responses, AI agents need broad access to various data sources and knowledge bases. Classic RBAC proves too rigid for this need - you can’t simply assign static permissions when the data requirements change based on context. This calls for a more sophisticated, Atribucións baseadasEnfoque que pode tomar decisións de acceso dinámico.

Outra preocupación son os novos vectores de ataque que introducen os sistemas de IA. As medidas de seguridade convencionais non foron deseñadas para manexar ataques de inxección rápida, intentos de extracción de modelos ou ataques de intoxicación de datos.

A solución vén en forma dun marco de seguridade integral construído ao redor de catro perímetros esenciais.

A solución: o marco de catro perímetros

Como as aplicacións de IA difiren do software estándar en como procesan entradas, recuperan datos, executan accións e xeran saídas, tamén introducen riscos de seguridade únicos.Para abordar estes retos, necesitamos un enfoque estruturado de seguridade que aplique control de acceso en cada etapa da interacción de IA.

A súaFour-Perimeter Frameworkestá deseñado para facer valer a conciencia da identidade,Autorización de graos finos ao longo do ciclo de vida da AIIntroduce límites de seguridade que regulan que modelos de datos de IA poden acceder, que operacións poden realizar e como se validan as súas respostas.

O marco consta de catro partes:

que
1. Prompt Filtering – Ensuring only validated, safe inputs reach AI models.
que
2. Protección de datos RAG - Controlar o acceso da IA a fontes de coñecemento externas.
que
3. Acceso externo seguro: Definición de permisos de axentes de IA ao interactuar con ferramentas externas.
que
4. Response Enforcement - Aplicando controis de cumprimento e filtrando as saídas xeradas por IA.
que

Aplicandofine-grained access control (FGA)os principios a través destes perímetros, os axentes de IA permanecensecure, auditable, and compliantsen sacrificar a súa flexibilidade e funcionalidade.

Onde entra o FGA?

Como se mencionou anteriormente, os métodos tradicionais de control de acceso como o RBAC non poden manexar o comportamento dinámico e contextual da IA. É aquí onde entra en xogo a autorización de gran fino (FGA), especificamente a través do control de acceso baseado en atributos (ABAC) e o control de acceso baseado en relacións (ReBAC):

que
• ABAC para os modelos de intelixencia artificial procesan entradas non estruturadas, o que dificulta a aplicación de regras de seguridade tradicionais. ABAC resolve isto extraendo atributos estruturados de intelixencia artificial e usándoos en decisións de acceso baseadas en políticas.
que

que
• ReBAC para RAG Data Protection Retrieval-Augmented Generation (RAG) permite que os modelos de IA extraan información de bases de datos vectoras. ReBAC proporciona unha forma natural de fortalecer a seguridade nesta configuración definindo relacións entre usuarios, fontes de datos e axentes de IA. En lugar de asignar permisos estáticos, ReBAC dinámicamente concede ou nega o acceso en función de como os obxectos de datos se relacionan entre si, permitindo permisos de recuperación conscientes do contexto.
que

Ao combinar ABAC e ReBAC, as aplicacións de IA obteñen mecanismos flexibles de control de acceso baseados en políticas que se adaptan a diferentes fluxos de traballo de IA sen necesidade de intervención manual.

Como é unha implementación paso a paso?

Imos percorrer unha aplicación práctica para ver oFour-Perimeter Framework in actionEste exemplo asegura un axente AI porvalidating prompts, enforcing data protection, restricting external access, and moderating responsesLevantamentoPermiso.eu AI Access ControlIntegración en cada paso.

1. Implement Prompt Filtering

O primeiro perímetro de seguridade céntrase en validar e sanitar as entradas de IA antes de que cheguen ao modelo.

• Os controis de autorización están incorporados á vía de validación inmediata, evitando que os datos non autorizados inflúan nas saídas de IA.
que
• O control de acceso baseado en roles, atributos e relacións é aplicado, garantindo que só os parámetros aprobados pasen á AI.
que
• Calquera violación de políticas é rexistrada e bloqueada en tempo real, preservando un rastro audible de decisións de acceso.
que

Aquí están os tres métodos para filtrar prompts - do máis sinxelo ao máis avanzado:

que
1. Validación de token - Un método eficiente para comprobacións simples como a lonxitude do prompt ou a admisión xeral de entradas en execución no sistema. funcións de verificación de permisos neste método examinan os atributos estruturados dos prompts de texto.
que
2. Matching de patróns: neste método, a comprobación de permisos examina os patróns no texto prompt, por exemplo, comprobando se o patrón coincide cunha consulta SQL ou exemplo de código.
que
3. A clasificación de IA é o método máis avanzado nesta lista, a clasificación de IA utiliza a IA para analizar o prompt usando un prompt de sistema dedicado, clasificándoo nunha entrada estruturada que pode ser analizada con precisión na verificación de permisos.
que

Prompt Filtering with PydanticAI

Para demostrar mellor a implementación da filtración de prompt eficiente, aquí está un exemplo de usar as ferramentas PydanticAI para filtrar as entradas do usuario aos axentes de IA. PydanticAI é un marco de axentes que aproveita a famosa biblioteca Pydantic de Python e as súas capacidades de escritura estática e convértea nun marco de IA estruturado que xestiona datos non estruturados.

O seguinte repositorio de GitHub contén unha implementación completa do marco para PydanticAI:github.com/permitio/permit-pydanticai

@financial_agent.tool
async def validate_financial_query(
    ctx: RunContext[PermitDeps],
    query: FinancialQuery,
) -> bool:
    """Key checks:
    - User has explicitly opted in to AI financial advice
    - Consent is properly recorded and verified
    - Classifies if the prompt is requesting advice

    Args:
        ctx: Context containing Permit client and user ID
        query: The financial query to validate

    Returns:
        bool: True if user has consented to AI advice, False otherwise
    """
    try:
        # Classify if the prompt is requesting advice
        is_seeking_advice = classify_prompt_for_advice(query.question)

        permitted = await ctx.deps.permit.check(
            # The user object with their attributes
            {
                "key": ctx.deps.user_id,
            },
            # The action being performed
            "receive",
            # The resource being accessed
            {
                "type": "financial_advice",
                "attributes": {"is_ai_generated": is_seeking_advice},
            },
        )

        if not permitted:
            if is_seeking_advice:
                return "User has not opted in to receive AI-generated financial advice"
            else:
                return "User does not have permission to access this information"

        return True

    except PermitApiError as e:
        raise SecurityError(f"Permission check failed: {str(e)}")

2. Enforce Data Protection –

A continuación, aseguramosretrieval-augmented generation (RAG)as consultas, asegurando que os modelos de IA só poden accederauthorized knowledge sourcesIsto pódese lograr mediante a filtración finamente granulada dos datos do axente de IA en nome do usuario dentro do fluxo de traballo de IA:

que
• A política finamente granulada usa modelos avanzados de filtración de datos, como o control de acceso baseado en relacións, para permitir a filtración de consultas avanzada ao motor de políticas.
que
• As fontes vector e gráficas conectadas aos axentes de IA teñen metadatos que poden axudar ao motor a manipular a consulta non estruturada, filtrándoa para incluír só datos permitidos.
que
• Cada vez que o axente obtén datos da base de coñecemento RAG, filtra os resultados por permiso do usuario.
que

Cando a aplicación do axente realiza a filtración RAG, utiliza un dos seguintes métodos:

que
• FilterObjects—Neste método, a aplicación gráfica obtén todos os datos relevantes do RAG e logo filtra por permisos de usuario.A vantaxe desta función é que mantén o motor de políticas sen estado e descoñecido dos datos RAG.
que
• GetUserPermissions - Neste método, o axente proporciona á RAG unha consulta non estruturada. A RAG chama a función GetUserPermissions, anexando unha consulta de filtro á consulta RAG non estruturada.
que

RAG Data Protection with Langchain

Langchain, o famoso marco de aplicacións de IA, é coñecido (tamén) polos seus compoñentes de retriever que proporcionan un gran soporte en retrievers personalizados que se poden montar con calquera tipo de fonte de datos, facendo a implementación de RAG seguro fácil.SelfQueryRetriever, podes envolver o RAG habitual cunhaGetUserPermissionsAquí está un exemplo do PermitSelfQueryRetriever que obtén o usuario, a acción e o tipo de recursos RAG para filtrar os resultados para o LLM:

# 1. Build a small in-memory vector store
  embeddings = OpenAIEmbeddings()
  vectorstore = FAISS.from_documents(docs, embedding=embeddings)

# 2. Initialize the PermitSelfQueryRetriever
retriever = PermitSelfQueryRetriever(
    api_key=os.getenv("PERMIT_API_KEY", ""),
    pdp_url=os.getenv("PERMIT_PDP_URL"),
    user=USER,
    resource_type=RESOURCE_TYPE,
    action=ACTION,
    llm=embeddings,
    vectorstore=vectorstore,
    enable_limit=False,
)

O seguinte repositorio contén a implementación completa do marco para Langchain:https://github.com/permitio/langchain-permit

3. Secure External Access –

Os axentes de IA a miúdo interactúan con APIs, servizos e ferramentas de automatización externas. Sen un control de acceso adecuado, corren o risco de executar accións non autorizadas.

que
• Usar modelos como o MCP, que define un modelo servidor-cliente onde os axentes de IA interactúan con servizos externos, é un gran paso para permitir a seguridade para o acceso externo de IA (por exemplo, bases de datos, APIs, sistemas de pagamento).
que
• A infraestrutura de acción de IA pode usar un servizo como Permit.io para realizar controis de autorización no nivel de acción, comprobar quen está a facer unha solicitude e que acción queren realizar.
que
• Os desenvolvedores poden asignar identidades de máquinas aos axentes de IA, limitando as súas capacidades só a funcións pre-aprovadas.
que

Aínda que os GPT e as interfaces de linguaxe natural non son novas, permitirlles realizar accións en nome dos usuarios é un reto relativamente novo que moitos enxeñeiros loitan con.

que
1. Un usuario pide a un axente de IA que realice unha operación, como unha chamada HTTP. O axente de IA sabe comprobar se a operación está permitida, tendo en conta o contexto actual e o usuario.
que
2. Comunicación de axente a axente - neste seguinte nivel, necesitamos un fluxo en cascada de identidades e permisos que permitan aos axentes realizar accións baseadas no principio do privilexio mínimo.
que
3. O nivel máis emocionante de acceso externo é cando o axente de IA entende a necesidade de solicitar o acceso directamente dun usuario humano cando quere realizar unha operación.
que

MCP, Human-in-the-Loop, and External Access

Model Context Protocol é un novo protocolo introducido por Anthropic, que resolve o problema de permitir que os axentes de IA realicen accións proactivas e serve como o maior facilitador para asegurar o acceso externo.

No seguinte exemplo, mostramos un servidor MCP que sabe como xestionar os fluxos de solicitudes de acceso introducindo humanos no loop e usa as APIs de Permit.io para solicitar permisos.

Podes ver o exemplo de código completo para o servidor de solicitudes de acceso de MCP aquí:https://github.com/permitio/permit-mcp Páxina web

@mcp.tool()
async def request_access(username: str, resource: str, resource_name: str) -> dict:
  """
  Initiate access request call to a specific resource in the system

  Args:
    username: The username of the person requesting access
    resource: The resource type the user is request access for
    resource_name: The name of the restaurant to request access for

  """
  
  login = await permit.elements.login_as({ "userId": slugify(username), "tenant": "default"})
  print(login)
  
  url = f"https://api.permit.io/v2/facts/{PROJECT_ID}/{ENV_ID}/access_requests/{ELEMENTS_CONFIG_ID}/user/{slugify(username)}/tenant/default"
  payload = {
      "access_request_details": {
          "tenant": "default",
          "resource": resource,
          "resource_instance": resource_name['id'],
          "role": "viewer",
      },
      "reason": f"User {username} requests role 'viewer' for {resource_name}"
  }
  headers = {
      "authorization": "Bearer YOUR_API_SECRET_KEY",
      "Content-Type": "application/json",
  }
  async with httpx.AsyncClient() as client:
      await client.post(url, json=payload, headers=headers)
      return "Your request has been sent. Please check back later."

4. Validate AI Responses –

O perímetro final impón a moderación de contido e o cumprimento das respostas xeradas por IA. Isto pódese facer creando un fluxo de traballo que aplica a filtración baseada en políticas antes de entregar as saídas de IA:

que
• Pode engadirse unha verificación de permisos á aplicación do axente, permitindo a aplicación de políticas en cada paso da cadea antes de que o usuario reciba unha resposta.
que
• Os fluxos de traballo de validación e autorización de datos combinados aseguran que só os datos validados e permitidos poden avanzar.
que
• A resposta que devolve aos usuarios pode ser editada en base a limitacións predefinidas, permitindo así a mascarada de datos ou notificando ao usuario das limitacións de uso.
que

Response Filtering with Langflow

No seguinte exemplo, usamos Langflow, un editor visual de aplicacións de IA sen código, para crear un compoñente de verificación de permisos que está posicionado antes de calquera resposta de chat ao usuario. Usando as capacidades de modelado de fluxo amigables de LangFlow, pode facilmente anexar outro compoñente que oculta os detalles non desexados nas respostas devoltas.Este repositorioContén todos os compoñentes de control de acceso necesarios para aplicacións seguras de Langflow.

Conclusión

AI systems are rapidly integrating into applications across industries, but their security frameworks remain underdeveloped compared to traditional software. Without proper identity-aware access control, AI agents risk exposing sensitive data, executing unauthorized operations, and generating responses that fall outside compliance guidelines.

O marco de catro perímetros ofrece unha forma estruturada de asegurar os fluxos de traballo de IA en todas as etapas, desde a validación de prompts e a protección de datos de xeración aumentada por recuperación (RAG) ata o control de accións externas impulsadas por IA e a aplicación da conformidade de resposta. Ao aproveitar a autorización de gran fino (FGA) con ABAC e ReBAC, os desenvolvedores poden garantir que os axentes de IA permanezan funcionais e seguros, adaptándose dinámicamente a escenarios de seguridade do mundo real.

En lugar de construír control de acceso desde o principio, as integracións de control de acceso de IA de Permit.io con PydanticAI, LangChain, MCP e LangFlow permiten que os equipos incorporen a seguridade directamente ás súas aplicacións de IA sen interromper os fluxos de traballo de desenvolvemento.Proba a ti mesmo aquí. .

Dito isto, este campo aínda é relativamente novo, e as mellores prácticas para asegurar os axentes de IA aínda están evolucionando. O Marco de Catro Perímetros é un enfoque experimental, e aínda que proporciona unha base sólida, recoñezo que as implementacións do mundo real sempre requiren máis refinamento e adaptación.

Gustaríame escoitar o seu feedback, pensamentos e ideas sobre como mellorar este marco para facelo aínda mellor para sistemas de IA listos para a produción - comente aquí, ou chégame ao nosoSlack Comunidade. .